GOSemSim

https://github.com/yulab-smu/gosemsim
Admin
GOSemSim is an R package for computing semantic similarity among Gene Ontology (GO) terms, sets of...
Tokens:10,709
Snippets:76
Trust Score:8.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install GOSemSim from Bioconductor

Source: https://github.com/yulab-smu/gosemsim/blob/devel/README.md

Install the released version of the GOSemSim package using BiocManager. Ensure BiocManager is installed first, and consider installing BiocUpgrade if needed.

```r
if (!requireNamespace("BiocManager", quietly=TRUE))
    install.packages("BiocManager")
## BiocManager::install("BiocUpgrade") ## you may need this
BiocManager::install("GOSemSim")
```

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

### Install GOSemSim Development Version from GitHub

Source: https://github.com/yulab-smu/gosemsim/blob/devel/README.md

Install the development version of the GOSemSim package directly from its GitHub repository using the remotes package.

```r
## install.packages("remotes")
remotes::install_github("YuLab-SMU/GOSemSim")
```

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

### Install GOSemSim Package

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Provides R code for installing the GOSemSim package from Bioconductor (stable) or GitHub (development version).

```r
# From Bioconductor (stable release)
if (!requireNamespace("BiocManager", quietly = TRUE))
    install.packages("BiocManager")
BiocManager::install("GOSemSim")
```

```r
# Development version from GitHub
# install.packages("remotes")
remotes::install_github("YuLab-SMU/GOSemSim")
```

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

### Clone and Configure GOSemSim Repository

Source: https://github.com/yulab-smu/gosemsim/wiki/git-for-GOSemSim

Clone the GOSemSim repository and set up remotes to synchronize with the Bioconductor upstream repository. This process ensures the local master branch is updated from Bioconductor.

```bash
git clone git@github.com:GuangchuangYu/GOSemSim.git
cd GOSemSim
git remote add upstream git@git.bioconductor.org:packages/GOSemSim.git
git fetch --all
git checkout master
git merge origin/master
git checkout -b master_backup upstream/master
git branch -m master github
git branch -m master_backup master
```

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

### Extend GO Annotations with Ancestors (buildGOmap)

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Expands a data frame of direct GO-to-gene mappings by adding all ancestor GO terms from the GO hierarchy. Essential for IC computation with custom annotation data.

```r
library(GOSemSim)

# Minimal data.frame: GO term, GENE ID, and ONTOLOGY
direct_anno <- data.frame(
  GO       = c("GO:0004022", "GO:0005515"),
  GENE     = c("gene1",      "gene2"),
  ONTOLOGY = c("MF",         "MF")
)

# Adds all GO ancestor terms from the hierarchy
extended_anno <- buildGOmap(direct_anno)
head(extended_anno)
#           GO  GENE ONTOLOGY
# 1 GO:0004022 gene1       MF
# 2 GO:0005515 gene2       MF
# 3 GO:0003824 gene1       MF   # ancestor added
# ...

# Use with godata() for IC-based methods
d <- godata(annoDb = extended_anno, ont = "MF", computeIC = TRUE)
```

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

### buildGOmap()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Extends direct GO annotations with their indirect ancestors by traversing the GO hierarchy. This is essential for computing Information Content (IC) when using custom annotation data.

```APIDOC
## buildGOmap() — Extend Direct GO Annotations with Indirect Ancestors

### Description
Given a data frame of direct GO-to-gene mappings, traverses the GO hierarchy to add all ancestor (indirect) GO annotations. Required for IC computation when using custom annotation data.

### Parameters
- **direct_anno** (data.frame) - A data frame with columns 'GO', 'GENE', and 'ONTOLOGY' representing direct annotations.

### Returns
A data frame with extended annotations, including all ancestor GO terms for each gene.

### Example
```r
library(GOSemSim)
direct_anno <- data.frame(
  GO       = c("GO:0004022", "GO:0005515"),
  GENE     = c("gene1",      "gene2"),
  ONTOLOGY = c("MF",         "MF")
)
extended_anno <- buildGOmap(direct_anno)
print(head(extended_anno))
```
```

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

### Calculate Semantic Similarity Between Two Sets of GO Terms with mgoSim()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Given two vectors of GO term IDs, computes an aggregated similarity score using a pairwise term-similarity matrix combined by the chosen 'combine' strategy. Supports various aggregation methods and can return the raw pairwise matrix.

```R
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

go1 <- c("GO:0004022", "GO:0004024", "GO:0004023")
go2 <- c("GO:0009055", "GO:0020037")

# BMA (Best Match Average) is the default and most commonly used combine method
mgoSim(go1, go2, semData = d, measure = "Wang", combine = "BMA")
# [1] 0.338

# Single term vs. a set
mgoSim("GO:0003824", go2, semData = d, measure = "Wang", combine = "BMA")

# Available combine strategies: "BMA", "avg", "max", "rcmax", "rcmax.avg"
mgoSim(go1, go2, semData = d, measure = "Wang", combine = "avg")
mgoSim(go1, go2, semData = d, measure = "Wang", combine = "max")

# Return the raw pairwise matrix (no aggregation)
mgoSim(go1, go2, semData = d, measure = "Wang", combine = NULL)
```

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

### mgoSim() — Semantic Similarity Between Two Sets of GO Terms

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Given two vectors of GO term IDs, computes an aggregated similarity score using a pairwise term-similarity matrix combined by the chosen `combine` strategy.

```APIDOC
## mgoSim() — Semantic Similarity Between Two Sets of GO Terms

### Description
Given two vectors of GO term IDs, computes an aggregated similarity score using a pairwise term-similarity matrix combined by the chosen `combine` strategy.

### Usage
```r
mgoSim(GO1, GO2, semData, measure, combine = "BMA")
```

### Parameters
* `GO1`: A vector of GO term IDs.
* `GO2`: A vector of GO term IDs.
* `semData`: A `GOSemSimDATA` object, typically generated by `godata()`.
* `measure`: The semantic similarity method to use (e.g., "Wang", "Resnik", "Lin", "Jiang", "Rel", "TCSS").
* `combine`: Strategy for combining term similarities. Available options: "BMA" (default), "avg", "max", "rcmax", "rcmax.avg", or `NULL` to return the raw pairwise matrix.

### Request Example
```r
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

go1 <- c("GO:0004022", "GO:0004024", "GO:0004023")
go2 <- c("GO:0009055", "GO:0020037")

# BMA combine strategy
mgoSim(go1, go2, semData = d, measure = "Wang", combine = "BMA")

# Single term vs. a set
mgoSim("GO:0003824", go2, semData = d, measure = "Wang", combine = "BMA")

# Using 'avg' combine strategy
mgoSim(go1, go2, semData = d, measure = "Wang", combine = "avg")

# Using 'max' combine strategy
mgoSim(go1, go2, semData = d, measure = "Wang", combine = "max")

# Return the raw pairwise matrix
mgoSim(go1, go2, semData = d, measure = "Wang", combine = NULL)
```

### Response
Returns a single numeric similarity score or a pairwise similarity matrix.
```

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

### Prepare Semantic Data Object with godata()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Loads gene-to-GO annotation data and computes Information Content (IC) for a given organism and ontology. Returns a GOSemSimDATA object required by all similarity functions. Accepts an OrgDb package name, OrgDb object, or a custom data.frame.

```R
library(GOSemSim)
library(org.Hs.eg.db)

# Prepare MF data with IC computation (required for IC-based methods)
d_mf <- godata("org.Hs.eg.db", ont = "MF", computeIC = TRUE)
# preparing gene to GO mapping data...
# preparing IC data...

# Prepare BP data without IC (suitable for Wang method only)
d_bp <- godata("org.Hs.eg.db", ont = "BP", computeIC = FALSE)

# Prepare data with TCSS support
d_tcss <- godata("org.Hs.eg.db", ont = "BP",
                 computeIC = TRUE, processTCSS = TRUE, cutoff = NULL)

# Use a custom data.frame annotation (e.g., from read.gaf or read.blast2go)
# my_anno must have columns: GENE, GO, ONTOLOGY
d_custom <- godata(annoDb = my_anno, ont = "BP", computeIC = TRUE)

# Inspect the resulting object
d_mf
```

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

### termSim() — Pairwise Term Similarity Matrix

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Computes a full pairwise similarity matrix between two vectors of ontology terms. This is the low-level engine used internally by `goSim()` and `mgoSim()`, but is also directly accessible.

```APIDOC
## termSim() — Pairwise Term Similarity Matrix

### Description
Computes a full pairwise similarity matrix between two vectors of ontology terms. This is the low-level engine used internally by `goSim()` and `mgoSim()`, but is also directly accessible. Supports methods: `"Wang"`, `"Resnik"`, `"Rel"`, `"Jiang"`, `"Lin"`, `"TCSS"`.

### Usage
```r
termSim(terms1, terms2, semData, method)
```

### Parameters
* `terms1`: A vector of GO term IDs.
* `terms2`: A vector of GO term IDs.
* `semData`: A `GOSemSimDATA` object, typically generated by `godata()`.
* `method`: The semantic similarity method to use (e.g., "Wang", "Resnik", "Lin", "Jiang", "Rel", "TCSS").

### Request Example
```r
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

t1 <- c("GO:0004022", "GO:0004024")
t2 <- c("GO:0009055", "GO:0020037")

# Returns a matrix: rows = t1 terms, cols = t2 terms
mat <- termSim(t1, t2, semData = d, method = "Wang")
print(mat)

# TCSS method (requires processTCSS = TRUE in godata)
d_tcss <- godata("org.Hs.eg.db", ont = "BP", computeIC = TRUE, processTCSS = TRUE)
termSim("GO:0000012", "GO:0009987", semData = d_tcss, method = "TCSS")
```

### Response
Returns a matrix where rows correspond to `terms1` and columns correspond to `terms2`, containing the pairwise similarity scores.
```

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

### Parse BLAST2GO Annotation Files with read.blast2go()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Reads a BLAST2GO tab-delimited file into a data frame. Requires `readr`, `tidyr`, and `tidyselect`. Use `add_indirect_GO = TRUE` to include ancestor terms.

```r
library(GOSemSim)
# install.packages(c("readr", "tidyr", "tidyselect"))  # if not installed

anno <- read.blast2go("path/to/blast2go_results.txt")
head(anno)
#        GENE         GO ONTOLOGY
# 1 Sequence1  GO:0003824       MF
# 2 Sequence1  GO:0016787       MF
# 3 Sequence2  GO:0008150       BP
```

```r
# Add indirect ancestor annotations
anno_full <- read.blast2go("path/to/blast2go_results.txt", add_indirect_GO = TRUE)
```

```r
# Use with godata() for semantic similarity computation
d <- godata(annoDb = anno, ont = "MF", computeIC = TRUE)
goSim("GO:0003824", "GO:0016787", semData = d, measure = "Resnik")
```

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

### Compute Pairwise Term Similarity Matrix with termSim()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Computes a full pairwise similarity matrix between two vectors of ontology terms. This is the low-level engine used internally by goSim() and mgoSim(). Supports multiple similarity methods and requires specific data preparation for TCSS.

```R
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

t1 <- c("GO:0004022", "GO:0004024")
t2 <- c("GO:0009055", "GO:0020037")

# Returns a matrix: rows = t1 terms, cols = t2 terms
mat <- termSim(t1, t2, semData = d, method = "Wang")
print(mat)
#             GO:0009055 GO:0020037
# GO:0004022  0.1001     0.1701
# GO:0004024  0.1098     0.1866

# TCSS method (requires processTCSS = TRUE in godata)
d_tcss <- godata("org.Hs.eg.db", ont = "BP",
                 computeIC = TRUE, processTCSS = TRUE)
termSim("GO:0000012", "GO:0009987", semData = d_tcss, method = "TCSS")
```

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

### GOSemSim Citation Reference

Source: https://github.com/yulab-smu/gosemsim/wiki/Proper-use-of-GOSemSim

This is the recommended reference format for citing GOSemSim in R package man files when its code is copied or derived.

```R
\references{
  Yu et al. (2010) GOSemSim: an R package for measuring
  semantic similarity among GO terms and gene products
  \emph{Bioinformatics} (Oxford, England), 26:7 976--978,
  April 2010. ISSN 1367-4803
  \url{http://bioinformatics.oxfordjournals.org/cgi/content/abstract/26/7/976}
  PMID: 20179076
  }
```

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

### Parse GAF Annotation Files with read.gaf()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Parses a GAF file into a standardized data frame. Use `asis = TRUE` to retain original columns or `add_indirect_GO = TRUE` to include ancestor terms. `parse_gff()` is an alias.

```r
library(GOSemSim)

# Read a GAF file (simplified output)
anno <- read.gaf("path/to/annotations.gaf")
head(anno)
#   GENE          GO ONTOLOGY
# 1 P04637  GO:0003677       MF
# 2 P04637  GO:0046872       MF
# 3 P04637  GO:0008134       MF
```

```r
# Return the full original columns from the GAF file
anno_full <- read.gaf("path/to/annotations.gaf", asis = TRUE)
```

```r
# Automatically add indirect (ancestor) GO annotations
anno_expanded <- read.gaf("path/to/annotations.gaf", add_indirect_GO = TRUE)
```

```r
# parse_gff is an alias for read.gaf
anno2 <- parse_gff("path/to/annotations.gaf")
```

```r
# Use parsed GAF data directly in godata()
d <- godata(annoDb = anno, ont = "MF", computeIC = TRUE)
```

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

### read.blast2go()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Reads a BLAST2GO tab-delimited result file and returns a data frame with columns `GENE`, `GO`, and `ONTOLOGY`. It can also add indirect ancestor annotations.

```APIDOC
## `read.blast2go()` — Parse BLAST2GO Annotation Files

Reads a BLAST2GO tab-delimited result file and returns a data frame with columns `GENE`, `GO`, and `ONTOLOGY`. Requires the `readr`, `tidyr`, and `tidyselect` packages.

```r
library(GOSemSim)
# install.packages(c("readr", "tidyr", "tidyselect"))  # if not installed

anno <- read.blast2go("path/to/blast2go_results.txt")
head(anno)

# Add indirect ancestor annotations
anno_full <- read.blast2go("path/to/blast2go_results.txt", add_indirect_GO = TRUE)

# Use with godata() for semantic similarity computation
d <- godata(annoDb = anno, ont = "MF", computeIC = TRUE)
goSim("GO:0003824", "GO:0016787", semData = d, measure = "Resnik")
```
```

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

### read.gaf() / parse_gff()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Parses a GO Annotation Format (GAF) file. It can return a standardized data frame or the full original columns, and optionally expands annotations to include ancestor terms. `parse_gff` is an alias for `read.gaf`.

```APIDOC
## `read.gaf()` / `parse_gff()` — Parse GAF Annotation Files

Parses a GO Annotation Format (GAF) file and returns a standardized data frame with columns `GENE`, `GO`, and `ONTOLOGY`. Optionally expands direct annotations to include all ancestor terms.

```r
library(GOSemSim)

# Read a GAF file (simplified output)
anno <- read.gaf("path/to/annotations.gaf")
head(anno)

# Return the full original columns from the GAF file
anno_full <- read.gaf("path/to/annotations.gaf", asis = TRUE)

# Automatically add indirect (ancestor) GO annotations
anno_expanded <- read.gaf("path/to/annotations.gaf", add_indirect_GO = TRUE)

# parse_gff is an alias for read.gaf
anno2 <- parse_gff("path/to/annotations.gaf")

# Use parsed GAF data directly in godata()
d <- godata(annoDb = anno, ont = "MF", computeIC = TRUE)
```
```

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

### goSim() — Semantic Similarity Between Two GO Terms

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Computes the semantic similarity score between a pair of GO term IDs using the specified method. Returns a single numeric value between 0 and 1.

```APIDOC
## goSim() — Semantic Similarity Between Two GO Terms

### Description
Computes the semantic similarity score between a pair of GO term IDs using the specified method. Returns a single numeric value between 0 and 1.

### Usage
```r
goSim(GO1, GO2, semData, measure, combine = "BMA")
```

### Parameters
* `GO1`: The first GO term ID.
* `GO2`: The second GO term ID.
* `semData`: A `GOSemSimDATA` object, typically generated by `godata()`.
* `measure`: The semantic similarity method to use (e.g., "Wang", "Resnik", "Lin", "Jiang", "Rel", "TCSS").
* `combine`: Strategy for combining term similarities (default is "BMA").

### Request Example
```r
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

# Wang method
goSim("GO:0004022", "GO:0005515", semData = d, measure = "Wang")

# IC-based methods (require computeIC = TRUE in godata)
d_ic <- godata("org.Hs.eg.db", ont = "MF", computeIC = TRUE)
goSim("GO:0004022", "GO:0005515", semData = d_ic, measure = "Resnik")
goSim("GO:0004022", "GO:0005515", semData = d_ic, measure = "Lin")
goSim("GO:0004022", "GO:0005515", semData = d_ic, measure = "Jiang")
goSim("GO:0004022", "GO:0005515", semData = d_ic, measure = "Rel")
```

### Response
Returns a numeric score between 0 and 1.
```

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

### Compute Pairwise Similarity Matrix for Gene Clusters (mclusterSim)

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Generates a pairwise semantic similarity matrix for multiple named gene clusters. Useful for comparing functional groups within a larger set.

```r
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

cluster1 <- c("835", "5261", "241")
cluster2 <- c("578", "582")
cluster3 <- c("307", "308", "317")
clusters <- list(a = cluster1, b = cluster2, c = cluster3)

sim_matrix <- mclusterSim(clusters, semData = d, measure = "Wang",
                           drop = "IEA", combine = "BMA")
print(sim_matrix)
#        a      b      c
# a  1.000  0.284  0.336
# b  0.284  1.000  0.246
# c  0.336  0.246  1.000
```

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

### Calculate Semantic Similarity Between Two GO Terms with goSim()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Computes the semantic similarity score between a pair of GO term IDs using the specified method. Returns a single numeric value between 0 and 1. IC-based methods require computeIC = TRUE during data preparation.

```R
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

# Wang method (graph-based, no IC required)
goSim("GO:0004022", "GO:0005515", semData = d, measure = "Wang")
# [1] 0.177

# IC-based methods (require computeIC = TRUE)
d_ic <- godata("org.Hs.eg.db", ont = "MF", computeIC = TRUE)
goSim("GO:0004022", "GO:0005515", semData = d_ic, measure = "Resnik")
goSim("GO:0004022", "GO:0005515", semData = d_ic, measure = "Lin")
goSim("GO:0004022", "GO:0005515", semData = d_ic, measure = "Jiang")
goSim("GO:0004022", "GO:0005515", semData = d_ic, measure = "Rel")
# Returns numeric score in [0, 1] for each method
```

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

### godata() — Prepare Semantic Data Object

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Loads gene-to-GO annotation data and computes Information Content (IC) for a given organism and ontology. Returns a GOSemSimDATA object required by all similarity functions.

```APIDOC
## godata() — Prepare Semantic Data Object

### Description
Loads gene-to-GO annotation data and computes Information Content (IC) for a given organism and ontology. Returns a `GOSemSimDATA` object required by all similarity functions. Accepts an OrgDb package name, OrgDb object, or a custom `data.frame` with columns `GENE`, `GO`, and `ONTOLOGY`.

### Usage
```r
godata(annoDb, ont, computeIC = TRUE, processTCSS = FALSE, cutoff = NULL)
```

### Parameters
* `annoDb`: An OrgDb package name, OrgDb object, or a custom `data.frame` with columns `GENE`, `GO`, and `ONTOLOGY`.
* `ont`: The GO sub-ontology to use (e.g., "BP", "MF", "CC").
* `computeIC`: Logical, whether to compute Information Content (IC). Required for IC-based methods.
* `processTCSS`: Logical, whether to process data for TCSS method.
* `cutoff`: Numeric, cutoff for IC calculation (default is NULL).

### Request Example
```r
library(GOSemSim)
library(org.Hs.eg.db)

# Prepare MF data with IC computation
d_mf <- godata("org.Hs.eg.db", ont = "MF", computeIC = TRUE)

# Prepare BP data without IC
d_bp <- godata("org.Hs.eg.db", ont = "BP", computeIC = FALSE)

# Prepare data with TCSS support
d_tcss <- godata("org.Hs.eg.db", ont = "BP", computeIC = TRUE, processTCSS = TRUE, cutoff = NULL)

# Use a custom data.frame annotation
# my_anno must have columns: GENE, GO, ONTOLOGY
d_custom <- godata(annoDb = my_anno, ont = "BP", computeIC = TRUE)
```

### Response
Returns a `GOSemSimDATA` object.
```

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

### mgeneSim()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Computes a pairwise semantic similarity matrix for a list of gene IDs. Displays a progress bar during computation.

```APIDOC
## mgeneSim() — Pairwise Similarity Matrix for a List of Genes

### Description
Computes an all-vs-all similarity matrix for a vector of gene IDs. Shows a progress bar during computation.

### Parameters
- **genes** (vector of strings) - A vector of Entrez gene IDs.
- **semData** (object) - A GOSemSim semantic data object.
- **measure** (string) - The similarity measure to use.
- **drop** (string or NULL) - GO evidence codes to drop. Defaults to "IEA".
- **combine** (string) - The method for combining GO term similarities.
- **verbose** (boolean) - If TRUE, displays a progress bar.

### Returns
A numeric matrix where rows and columns represent gene IDs and the values are their pairwise semantic similarity scores.

### Example
```r
library(GOSemSim)
d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)
genes <- c("835", "5261", "241", "994")
sim_matrix <- mgeneSim(genes, semData = d, measure = "Wang", drop = "IEA", verbose = TRUE)
print(sim_matrix)
```

### Note
Genes with no annotations are automatically removed from the result matrix.
```

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

### Push Changes to Upstream and Merge

Source: https://github.com/yulab-smu/gosemsim/wiki/git-for-GOSemSim

After making necessary commits, push changes to the upstream Bioconductor repository and merge the latest changes into the local 'github' branch. Finally, push the updated 'master' branch.

```bash
git push upstream master
git checkout github
git merge -m 'merge from bioc repo' upstream/master
git push -f origin HEAD:master
git checkout master
```

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

### mclusterSim()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Computes a pairwise semantic similarity matrix for a list of named gene clusters. Useful for comparing multiple functional groups simultaneously.

```APIDOC
## mclusterSim() — Pairwise Similarity Matrix for a List of Gene Clusters

### Description
Computes pairwise similarity scores between all combinations of named gene clusters in a list.

### Parameters
- **clusters** (list of vectors of strings) - A named list where each element is a vector of Entrez gene IDs representing a cluster.
- **semData** (object) - A GOSemSim semantic data object.
- **measure** (string) - The similarity measure to use.
- **drop** (string or NULL) - GO evidence codes to drop. Defaults to "IEA".
- **combine** (string) - The method for combining GO term similarities.

### Returns
A numeric matrix where rows and columns represent cluster names and the values are their pairwise semantic similarity scores.

### Example
```r
library(GOSemSim)
d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)
cluster1 <- c("835", "5261", "241")
cluster2 <- c("578", "582")
cluster3 <- c("307", "308", "317")
clusters <- list(a = cluster1, b = cluster2, c = cluster3)
sim_matrix <- mclusterSim(clusters, semData = d, measure = "Wang", drop = "IEA", combine = "BMA")
print(sim_matrix)
```
```

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

### Calculate Semantic Similarity Between Gene Clusters (clusterSim)

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Computes the semantic similarity between two sets of genes by aggregating their GO terms. Supports different similarity measures and evidence code filtering.

```r
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

cluster1 <- c("835", "5261", "241", "994")
cluster2 <- c("307", "308", "317", "321", "506", "540", "378", "388", "396")

score <- clusterSim(cluster1, cluster2, semData = d,
                    measure = "Wang", drop = "IEA", combine = "BMA")
print(score)
# [1] 0.296
```

```r
# IC-based method between two clusters
d_ic <- godata("org.Hs.eg.db", ont = "BP", computeIC = TRUE)
clusterSim(cluster1, cluster2, semData = d_ic, measure = "Resnik")
```

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

### Compute Pairwise Similarity Matrix for Genes (mgeneSim)

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Calculates an all-vs-all semantic similarity matrix for a list of gene IDs. Displays a progress bar during computation and automatically removes genes without annotations.

```r
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

genes <- c("835", "5261", "241", "994")
sim_matrix <- mgeneSim(genes, semData = d, measure = "Wang",
                       drop = "IEA", combine = "BMA", verbose = TRUE)
# |======================================================| 100%

print(sim_matrix)
#        835   5261    241    994
# 835  1.000  0.452  0.332  0.288
# 5261 0.452  1.000  0.374  0.296
# 241  0.332  0.374  1.000  0.511
# 994  0.288  0.296  0.511  1.000

# Genes with no annotations are automatically removed from the result matrix
```

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

### clusterSim()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Calculates the semantic similarity score between two sets of genes (clusters). It aggregates GO terms from both sets and computes similarity between the pooled term sets.

```APIDOC
## clusterSim() — Semantic Similarity Between Two Gene Clusters

### Description
Aggregates all GO terms from two sets of genes and computes similarity between the pooled term sets. Useful for comparing functional groups or pathways.

### Parameters
- **cluster1** (vector of strings) - A vector of Entrez gene IDs for the first cluster.
- **cluster2** (vector of strings) - A vector of Entrez gene IDs for the second cluster.
- **semData** (object) - A GOSemSim semantic data object.
- **measure** (string) - The similarity measure to use.
- **drop** (string or NULL) - GO evidence codes to drop. Defaults to "IEA".
- **combine** (string) - The method for combining GO term similarities.

### Returns
A numeric value representing the semantic similarity score between the two gene clusters.

### Example
```r
library(GOSemSim)
d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)
cluster1 <- c("835", "5261", "241", "994")
cluster2 <- c("307", "308", "317", "321", "506", "540", "378", "388", "396")
score <- clusterSim(cluster1, cluster2, semData = d, measure = "Wang", drop = "IEA", combine = "BMA")
print(score)
```
```

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

### Aggregate Similarity Score Matrix (combineScores)

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Reduces a pairwise similarity matrix to a single score using specified aggregation strategies like Best Match Average (BMA), mean, or max. Available for custom workflows.

```r
library(GOSemSim)

# Simulate a similarity matrix
m <- matrix(c(0.8, 0.3, 0.5, 0.9), nrow = 2,
            dimnames = list(c("GO:A", "GO:B"), c("GO:C", "GO:D")))

combineScores(m, combine = "BMA")    # Best Match Average (default)
# [1] 0.75
combineScores(m, combine = "avg")    # mean of all values
# [1] 0.625
combineScores(m, combine = "max")    # global maximum
# [1] 0.9
combineScores(m, combine = "rcmax")  # max of row-mean-max and col-mean-max
combineScores(m, combine = NULL)     # return matrix as-is (rounded)
```

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

### combineScores()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Aggregates a pairwise similarity matrix into a single numeric score using a specified strategy. This function is useful for summarizing similarity matrices from pairwise comparisons.

```APIDOC
## combineScores() — Aggregate a Similarity Score Matrix

### Description
Reduces a pairwise similarity matrix to a single numeric score using a named aggregation strategy. Called internally by `mgoSim()` and related functions, but available directly for custom workflows.

### Parameters
- **simMatrix** (matrix) - The input similarity matrix.
- **combine** (string or NULL) - The aggregation strategy. Options include "BMA" (Best Match Average), "avg" (mean), "max" (global maximum), "rcmax" (max of row-mean-max and col-mean-max). If NULL, the matrix is returned as-is (rounded).

### Returns
A single numeric score representing the aggregated similarity.

### Example
```r
library(GOSemSim)
m <- matrix(c(0.8, 0.3, 0.5, 0.9), nrow = 2, dimnames = list(c("GO:A", "GO:B"), c("GO:C", "GO:D")))
combineScores(m, combine = "BMA")
```
```

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

### geneSim()

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Calculates the semantic similarity score between two genes given their Entrez IDs. It can optionally filter GO terms by evidence codes.

```APIDOC
## geneSim() — Semantic Similarity Between Two Genes

### Description
Given two Entrez gene IDs, retrieves their GO annotations and returns the aggregated semantic similarity score along with the GO terms used.

### Parameters
- **gene1** (string) - Entrez gene ID for the first gene.
- **gene2** (string) - Entrez gene ID for the second gene.
- **semData** (object) - A GOSemSim semantic data object, typically created by `godata()`.
- **measure** (string) - The similarity measure to use (e.g., "Wang", "Resnik", "Lin", "Rel", "JC").
- **combine** (string) - The method for combining GO term similarities (e.g., "BMA", "max", "avg"). Defaults to "BMA".
- **drop** (string or NULL) - GO evidence codes to drop. Defaults to "IEA". Set to NULL to keep all.

### Returns
A list containing:
- **geneSim**: The numeric semantic similarity score.
- **GO1**: A vector of GO terms for the first gene.
- **GO2**: A vector of GO terms for the second gene.

### Example
```r
library(GOSemSim)
d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)
result <- geneSim("241", "251", semData = d, measure = "Wang", combine = "BMA")
print(result$geneSim)
```

### Note
Returns NA if either gene has no GO annotations after filtering.
```

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

### Calculate Semantic Similarity Between Two Genes (geneSim)

Source: https://context7.com/yulab-smu/gosemsim/llms.txt

Computes the semantic similarity score between two Entrez gene IDs using specified GO ontology and similarity measure. Can filter by evidence codes or return NA if no annotations are found.

```r
library(GOSemSim)

d <- godata("org.Hs.eg.db", ont = "MF", computeIC = FALSE)

# Compare two human genes (Entrez IDs)
result <- geneSim("241", "251", semData = d, measure = "Wang", combine = "BMA")
result$geneSim   # numeric similarity score
result$GO1       # GO terms for gene "241"
result$GO2       # GO terms for gene "251"
```

```r
# Drop specific evidence codes (default drops "IEA" — inferred from electronic annotation)
geneSim("241", "251", semData = d, measure = "Wang", drop = "IEA")
```

```r
# Keep all evidence codes
geneSim("241", "251", semData = d, measure = "Wang", drop = NULL)
```

```r
# Returns NA if either gene has no GO annotations after filtering
geneSim("9999999", "251", semData = d, measure = "Wang")
# [1] NA
```
Tokens:
Raw