GenotypeTableUtils

net.maizegenetics.dna.snp.GenotypeTableUtils

```
public class GenotypeTableUtils
```
Utility methods for comparing, sorting, and counting genotypes.

- Method Detail
  - getAllelesSortedByFrequency
```
public static kotlin.Array[] getAllelesSortedByFrequency(kotlin.Array[] data)
```
    This sorts alleles by frequency. Each cell in the given array contains a diploid value which is separated and counted individually. Resulting double dimension array holds alleles (bytes) in result[0]. And the counts are in result[1]. Counts haploid values twice and diploid values once. Higher ploids are not supported.
    
    Parameters:
    
    data - data
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@83568d5: alleles and counts
  - getAllelesSortedByFrequency
```
public static kotlin.Array[] getAllelesSortedByFrequency(kotlin.Array[] data,
                                                         int site)
```
    This sorts alleles in a given site by frequency. Each cell in the given array contains a diploid value which is separated and counted individually. Resulting double dimension array holds alleles (bytes) in result[0]. And the counts are in result[1]. Counts haploid values twice and diploid values once. Higher ploids are not supported.
    
    Parameters:
    
    data - data
    
    site - site
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@6447bbde: alleles and counts
  - getAlleles
```
public static kotlin.Array[] getAlleles(kotlin.Array[] data,
                                        int site)
```
  - getAllelesSortedByFrequency
```
public static java.lang.Object[] getAllelesSortedByFrequency(java.lang.String[] data,
                                                             int site)
```
  - convertNucleotideGenotypesToStringList
```
public static java.util.List<java.lang.String> convertNucleotideGenotypesToStringList(kotlin.Array[] data)
```
    Converts the byte representation of genotypes to string list of genotypes
    
    Parameters:
    
    data -
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@3e56d05e: list of the genotypes.
  - getAlleles
```
public static java.util.List<java.lang.String> getAlleles(java.lang.String[] data,
                                                          int site)
```
  - getAllelesSortedByFrequency
```
public static kotlin.Array[] getAllelesSortedByFrequency(GenotypeTable alignment,
                                                         int site)
```
  - getDiploidsSortedByFrequency
```
public static java.lang.Object[] getDiploidsSortedByFrequency(GenotypeTable alignment,
                                                              int site)
```
  - getAlleleStates
```
public static java.lang.String[] getAlleleStates(java.lang.String[] data,
                                                 int maxNumAlleles)
```
  - removeSitesBasedOnFreqIgnoreMissing
```
public static GenotypeTable removeSitesBasedOnFreqIgnoreMissing(GenotypeTable aa,
                                                                double minimumProportion,
                                                                double maximumProportion,
                                                                int minimumCount)
```
    remove sites based on minimum frequency (the count of good bases, INCLUDING GAPS) and based on the proportion of good alleles (including gaps) different from consensus
    
    Parameters:
    
    aa - the AnnotatedAlignment to filter
    
    minimumProportion - minimum proportion of sites different from the consensus
    
    minimumCount - minimum number of sequences with a good bases (not N or ?), where GAP IS CONSIDERED A GOOD BASE
  - filterSitesByBedFile
```
public static GenotypeTable filterSitesByBedFile(GenotypeTable input,
                                                 java.lang.String bedFile,
                                                 boolean includeSites)
```
    This returns the subset of genotypes specified by the given BED file. Start positions are inclusive and end positions are exclusive. If includeSites is false, this returns everything except the subset specified by the BED file.
    
    Parameters:
    
    input - original genotype
    
    bedFile - BED file specifying subset
    
    includeSites - whether to include sites
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@3737803: subset of genotypes
  - filterSitesByChrPos
```
public static GenotypeTable filterSitesByChrPos(GenotypeTable input,
                                                PositionList positionList,
                                                boolean includeSites)
```
  - filterSitesByChrPos
```
public static GenotypeTable filterSitesByChrPos(GenotypeTable input,
                                                java.lang.String filename,
                                                boolean includeSites)
```
  - keepSitesChrPos
```
public static GenotypeTable keepSitesChrPos(GenotypeTable input,
                                            java.lang.String chromosome,
                                            java.util.List<java.lang.Integer> position)
```
  - getIncludedSitesBasedOnFreqIgnoreMissing
```
public static kotlin.Array[] getIncludedSitesBasedOnFreqIgnoreMissing(GenotypeTable aa,
                                                                      double minimumProportion,
                                                                      double maximumProportion,
                                                                      int minimumCount)
```
    get sites to be included based on minimum frequency (the count of good bases, INCLUDING GAPS) and based on the proportion of good sites (INCLUDING GAPS) different from consensus
    
    Parameters:
    
    aa - the AnnotatedAlignment to filter
    
    minimumProportion - minimum proportion of sites different from the consensus
    
    maximumProportion - maximum proportion of sites different from the consensus
    
    minimumCount - minimum number of sequences with a good base or a gap (but not N or ?)
  - isHeterozygous
```
public static boolean isHeterozygous(byte diploidAllele)
```
    Returns whether diploid allele values are heterozygous. First 4 bits in byte is one allele value. Second 4 bits is other allele value.
    
    Parameters:
    
    diploidAllele - alleles
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@2023db78: true if allele values different; false if values the same.
  - isHomozygous
```
public static boolean isHomozygous(byte diploidAllele)
```
    Returns whether diploid allele values are homozygous. Unknown values return false.
    
    Parameters:
    
    diploidAllele -
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@79631de9: true if allele values are the same; false if unknown or not equal
  - isEqual
```
public static boolean isEqual(kotlin.Array[] alleles1,
                              kotlin.Array[] alleles2)
```
    Returns whether two diploid allele values are equal ignoring order.
    
    Parameters:
    
    alleles1 - diploid alleles 1
    
    alleles2 - diploid alleles 2
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@71bfe6bb: true if equal
  - isEqual
```
public static boolean isEqual(byte diploidAllele1,
                              byte diploidAllele2)
```
    Returns whether two diploid allele values are equal ignoring order.
    
    Parameters:
    
    diploidAllele1 - diploid alleles 1
    
    diploidAllele2 - diploid alleles 2
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@69143bef: true if equal
  - isEqualOrUnknown
```
public static boolean isEqualOrUnknown(kotlin.Array[] alleles1,
                                       kotlin.Array[] alleles2)
```
    Returns whether two diploid allele values are equal ignoring order where unknown values equal anything.
    
    Parameters:
    
    alleles1 - diploid alleles 1
    
    alleles2 - diploid alleles 2
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@5752d5ae: true if equal
  - isEqualOrUnknown
```
public static boolean isEqualOrUnknown(byte diploidAllele1,
                                       byte diploidAllele2)
```
    Returns whether two diploid allele values are equal ignoring order where unknown values equal anything.
    
    Parameters:
    
    diploidAllele1 - diploid alleles 1
    
    diploidAllele2 - diploid alleles 2
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@36bf16f8: true if equal
  - isPartiallyEqual
```
public static boolean isPartiallyEqual(byte genotype1,
                                       byte genotype2)
```
    Return true if either at least one allele agree
    
    Parameters:
    
    genotype1 -
    
    genotype2 -
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@38bbb4aa: true if at least one allele is equal
  - areEncodingsEqual
```
public static boolean areEncodingsEqual(java.lang.String[] encodings)
```
  - getDiploidValuePhased
```
public static byte getDiploidValuePhased(byte a,
                                         byte b)
```
    Combines two allele values into one diploid value. Assumed phased.
    
    Parameters:
    
    a - allele 1
    
    b - allele 2
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@70b83b11: diploid value
  - getDiploidValue
```
public static byte getDiploidValue(byte a,
                                   byte b)
```
    Combines two allele values into one diploid value. Assumed phased.
    
    Parameters:
    
    a - allele 1
    
    b - allele 2
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@31067f0d: diploid value
  - getUnphasedDiploidValue
```
public static byte getUnphasedDiploidValue(byte a,
                                           byte b)
```
    Combines two allele values into one diploid value. In alphabetical order
    
    Parameters:
    
    a - allele 1
    
    b - allele 2
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@7f40b703: diploid value sorted by order A < C < G < T
  - getUnphasedSortedDiploidValue
```
public static byte getUnphasedSortedDiploidValue(byte genotype)
```
    Ensures diploid value in alphabetical order
    
    Parameters:
    
    genotype - diploid genotype
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@1abb52a5: diploid value sorted by order A < C < G < T
  - getUnphasedDiploidValueNoHets
```
public static byte getUnphasedDiploidValueNoHets(byte g1,
                                                 byte g2)
```
    Combines two genotype values into one diploid value. Returns unknown if either parent is heterozygous or unknown, or alleles are swapped.
    
    Parameters:
    
    g1 - genotype 1
    
    g2 - genotype 2
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@2bea8250: diploid value
  - getDiploidValues
```
public static kotlin.Array[] getDiploidValues(byte genotype)
```
    Separates diploid allele value into it's two values.
    
    Parameters:
    
    genotype - diploid value
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@29966e37: separated allele values
  - calcBitPresenceFromGenotype
```
public static BitSet[] calcBitPresenceFromGenotype(kotlin.Array[] genotype,
                                                   kotlin.Array[] mjA,
                                                   kotlin.Array[] mnA)
```
    Method for getting TBits rapidly from major and minor allele arrays
    
    Parameters:
    
    genotype -
    
    mjA -
    
    mnA -
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@53942ca9:
  - calcBitPresenceOfDiploidValueFromGenotype
```
public static BitSet calcBitPresenceOfDiploidValueFromGenotype(kotlin.Array[] genotype,
                                                               byte diploidValue)
```
    Returns BitSet indicating presence of given diploid value in genotype. This does unphased comparisons, so the order of the two allele values do not matter. If given diploid value is UNKNOWN, then it doesn't match anything. Bits set to 1 indicate match.
    
    Parameters:
    
    genotype - genotype
    
    diploidValue - diploid value
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@137a7204: BitSet indicating presence
  - calcBitPresenceFromGenotype
```
public static BitSet calcBitPresenceFromGenotype(kotlin.Array[] genotype,
                                                 kotlin.Array[] referenceValues)
```
  - calcBitUnknownPresenceFromGenotype
```
public static BitSet calcBitUnknownPresenceFromGenotype(kotlin.Array[] genotype)
```
  - calcBitPresenceFromGenotype15
```
public static BitSet[] calcBitPresenceFromGenotype15(kotlin.Array[] genotype,
                                                     kotlin.Array[] mjA,
                                                     kotlin.Array[] mnA)
```
    Method for getting TBits rapidly from major and minor allele arrays
    
    Parameters:
    
    genotype -
    
    mjA -
    
    mnA -
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@6cfd9a39:
  - calcBitPresenceFromGenotype
```
public static BitSet[] calcBitPresenceFromGenotype(kotlin.Array[] genotype,
                                                   byte mj,
                                                   byte mn)
```
    Method for getting Site Bits rapidly from major and minor alleles
    
    Parameters:
    
    genotype -
    
    mj -
    
    mn -
    
    Returns:
    
    org.jetbrains.dokka.NodeRenderContent@7600b647:
  - calcBitPresenceFromGenotype
```
public static BitSet calcBitPresenceFromGenotype(kotlin.Array[] genotype,
                                                 byte referenceValue)
```
  - convertGenotypeToFloatProbability
```
public static kotlin.Array[] convertGenotypeToFloatProbability(GenotypeTable genotype,
                                                               boolean sitesByTaxa)
```
  - convertGenotypeToDoubleProbability
```
public static kotlin.Array[] convertGenotypeToDoubleProbability(GenotypeTable genotype,
                                                                boolean sitesByTaxa)
```

Class GenotypeTableUtils

Method Detail

getAllelesSortedByFrequency

getAllelesSortedByFrequency

getAlleles

getAllelesSortedByFrequency

convertNucleotideGenotypesToStringList

getAlleles

getAllelesSortedByFrequency

getDiploidsSortedByFrequency

getAlleleStates

removeSitesBasedOnFreqIgnoreMissing

filterSitesByBedFile

filterSitesByChrPos

filterSitesByChrPos

keepSitesChrPos

getIncludedSitesBasedOnFreqIgnoreMissing

isHeterozygous

isHomozygous

isEqual

isEqual

isEqualOrUnknown

isEqualOrUnknown

isPartiallyEqual

areEncodingsEqual

getDiploidValuePhased

getDiploidValue

getUnphasedDiploidValue

getUnphasedSortedDiploidValue

getUnphasedDiploidValueNoHets

getDiploidValues

calcBitPresenceFromGenotype

calcBitPresenceOfDiploidValueFromGenotype

calcBitPresenceFromGenotype

calcBitUnknownPresenceFromGenotype

calcBitPresenceFromGenotype15

calcBitPresenceFromGenotype

calcBitPresenceFromGenotype

convertGenotypeToFloatProbability

convertGenotypeToDoubleProbability