README

GoPHY

This is a development toolkit for phylogenetics. There are many different main packages that are typically in subdirectories. So, for example, the bipartition analyzer is in gophy/bp/ and is called bp.go. To get this code and compile things, just do go get github.com/FePhyFoFum/gophy. Then you can build it with go build github.com/FePhyFoFum/gophy/bp/bp.go. There are other mains in other subdirectories with more to come.

You can find more information here.

Documentation

Index

Constants

View Source
const (
	Nucleotide DataType = "nuc"
	AminoAcid           = "aa"
	MultiState          = "mult"
)

    datatype constants

    Variables

    This section is empty.

    Functions

    func AdjustBLNR

    func AdjustBLNR(node *Node, x *DiscreteModel, patternvals []float64, t *Tree, wks int, threshold float64)

      AdjustBLNR This is a single edge NR

      func AdjustBLNRMult

      func AdjustBLNRMult(node *Node, models []*DiscreteModel, nodemodels map[*Node]int, patternvals []float64, t *Tree, wks int, threshold float64)

        AdjustBLNRMult This is a single edge NR

        func BipartSliceContains

        func BipartSliceContains(bps []Bipart, bp Bipart) (ind int)

          BipartSliceContains checks to see if the bipart slice contains the bipart and returns the index

          func CalcAIC

          func CalcAIC(ln float64, k float64) (x float64)

            CalcAIC k=numparams

            func CalcAICC

            func CalcAICC(lnl float64, k float64, n int) (x float64)

              CalcAICC k=numparams,n=samplesize

              func CalcAncStates

              func CalcAncStates(x *DiscreteModel, tree *Tree, patternval []float64) (retstates map[*Node][][]float64)

                CalcAncStates for each node based on the calculations above

                func CalcBIC

                func CalcBIC(ln float64, k float64, n int) (x float64)

                  CalcBIC k=numparams, n=samplesize

                  func CalcConfIntLgLike

                  func CalcConfIntLgLike(nparams float64, perc float64) float64

                    CalcConfIntLgLike calculates the distance from the ML this is based on pg. 66 from In all Likelihood -.5*s.chi2(df).ppf(1-i) or -.5*s.norm(df,2*df).ppf(1-i) for large df

                    func CalcLikeFrontBack

                    func CalcLikeFrontBack(x *DiscreteModel, tree *Tree, patternval []float64)

                      CalcLikeFrontBack ...

                      func CalcLikeFrontBackMult

                      func CalcLikeFrontBackMult(models []*DiscreteModel, nodemodels map[*Node]int, tree *Tree, patternval []float64)

                        CalcLikeFrontBackMult ...

                        func CalcLikeNode

                        func CalcLikeNode(nd *Node, model *DiscreteModel, site int)

                          CalcLikeNode calculate the likelihood of a node

                          func CalcLikeNodeGamma

                          func CalcLikeNodeGamma(nd *Node, model *DiscreteModel, site int, gammav float64)

                            CalcLikeNodeGamma calculate the likelihood of a node

                            func CalcLikeOneSite

                            func CalcLikeOneSite(t *Tree, x *DiscreteModel, site int) float64

                              CalcLikeOneSite just one site

                              func CalcLikeOneSiteGamma

                              func CalcLikeOneSiteGamma(t *Tree, x *DiscreteModel, site int) float64

                                CalcLikeOneSiteGamma just one site

                                func CalcLikeOneSiteGammaMul

                                func CalcLikeOneSiteGammaMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, site int) float64

                                  CalcLikeOneSiteGamma just one site

                                  func CalcLikeOneSiteMarked

                                  func CalcLikeOneSiteMarked(t *Tree, x *DiscreteModel, site int) float64

                                    CalcLikeOneSiteMarked this uses the marked machinery to recalculate

                                    func CalcLikeOneSiteMarkedGamma

                                    func CalcLikeOneSiteMarkedGamma(t *Tree, x *DiscreteModel, site int) float64

                                      CalcLikeOneSiteMarkedGamma this uses the marked machinery to recalculate

                                      func CalcLikeOneSiteMarkedMul

                                      func CalcLikeOneSiteMarkedMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, site int) float64

                                        CalcLikeOneSiteMarkedMul this uses the marked machinery to recalculate

                                        func CalcLikeWork

                                        func CalcLikeWork(t *Tree, x *DiscreteModel, jobs <-chan int, results chan<- LikeResult)

                                          CalcLikeWork this is the worker

                                          func CalcLikeWorkGamma

                                          func CalcLikeWorkGamma(t *Tree, x *DiscreteModel, jobs <-chan int, results chan<- LikeResult)

                                            CalcLikeWorkGamma ...

                                            func CalcLikeWorkGammaMul

                                            func CalcLikeWorkGammaMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, jobs <-chan int, results chan<- LikeResult)

                                            func CalcLikeWorkMarked

                                            func CalcLikeWorkMarked(t *Tree, x *DiscreteModel, jobs <-chan int, results chan<- LikeResult)

                                              CalcLikeWorkMarked this is intended to calculate only on the marked nodes back to teh root

                                              func CalcLikeWorkMarkedGamma

                                              func CalcLikeWorkMarkedGamma(t *Tree, x *DiscreteModel, jobs <-chan int, results chan<- LikeResult)

                                                CalcLikeWorkMarkedGamma this is intended to calculate only on the marked nodes back to teh root

                                                func CalcLikeWorkMarkedMul

                                                func CalcLikeWorkMarkedMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, jobs <-chan int, results chan<- LikeResult)

                                                  CalcLikeWorkMarkedMul this is intended to calculate only on the marked nodes back to teh root

                                                  func CalcLogLikeNode

                                                  func CalcLogLikeNode(nd *Node, model *DiscreteModel, site int)

                                                    CalcLogLikeNode calculates likelihood for node

                                                    func CalcLogLikeNodeGamma

                                                    func CalcLogLikeNodeGamma(nd *Node, model *DiscreteModel, site int, gammav float64)

                                                      CalcLogLikeNodeGamma calculates likelihood for node

                                                      func CalcLogLikeOneSite

                                                      func CalcLogLikeOneSite(t *Tree, x *DiscreteModel, site int) float64

                                                        CalcLogLikeOneSite just calculate the likelihood of one site probably used to populate the PDict in the DNA Model so that we can reuse the calculations

                                                        func CalcLogLikeOneSiteBack

                                                        func CalcLogLikeOneSiteBack(t *Tree, nb *Node, x *DiscreteModel, site int) float64

                                                          CalcLogLikeOneSiteBack like the one above but from nb to the root only

                                                          func CalcLogLikeOneSiteGamma

                                                          func CalcLogLikeOneSiteGamma(t *Tree, x *DiscreteModel, site int) float64

                                                            CalcLogLikeOneSiteGamma ...

                                                            func CalcLogLikeOneSiteGammaMul

                                                            func CalcLogLikeOneSiteGammaMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, site int) float64

                                                              CalcLogLikeOneSiteGammaMul just one site

                                                              func CalcLogLikeOneSiteMarked

                                                              func CalcLogLikeOneSiteMarked(t *Tree, x *DiscreteModel, site int) float64

                                                                CalcLogLikeOneSiteMarked this uses the marked machinery to recalculate

                                                                func CalcLogLikeOneSiteMul

                                                                func CalcLogLikeOneSiteMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, site int) float64

                                                                  CalcLogLikeOneSiteMul just one site

                                                                  func CalcLogLikeWork

                                                                  func CalcLogLikeWork(t *Tree, x *DiscreteModel, jobs <-chan int, results chan<- LikeResult)

                                                                    CalcLogLikeWork this is intended for a worker that will be executing this per site

                                                                    func CalcLogLikeWorkBack

                                                                    func CalcLogLikeWorkBack(t *Tree, nb *Node, x *DiscreteModel, jobs <-chan int, results chan<- float64)

                                                                      CalcLogLikeWorkBack this is intended for a worker that will be executing this per site

                                                                      func CalcLogLikeWorkGamma

                                                                      func CalcLogLikeWorkGamma(t *Tree, x *DiscreteModel, jobs <-chan int, results chan<- LikeResult)

                                                                        CalcLogLikeWorkGamma this is intended for a worker that will be executing this per site

                                                                        func CalcLogLikeWorkGammaMul

                                                                        func CalcLogLikeWorkGammaMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, jobs <-chan int, results chan<- LikeResult)

                                                                        func CalcLogLikeWorkMarked

                                                                        func CalcLogLikeWorkMarked(t *Tree, x *DiscreteModel, jobs <-chan int, results chan<- float64)

                                                                          CalcLogLikeWorkMarked this is intended to calculate only on the marked nodes back to teh root

                                                                          func CalcLogLikeWorkMul

                                                                          func CalcLogLikeWorkMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, jobs <-chan int, results chan<- LikeResult)

                                                                            CalcLogLikeWorkMul this is the worker

                                                                            func CalcSankParsAncStateSingleSite

                                                                            func CalcSankParsAncStateSingleSite(t *Tree, numstates int, site int)

                                                                              CalcSankParsAncStateSingleSite .... assumes bifurcating for now

                                                                              func CalcSankParsNode

                                                                              func CalcSankParsNode(nd *Node, numstates int, site int)

                                                                                CalcSankParsNode ...

                                                                                func CalcSankParsWork

                                                                                func CalcSankParsWork(t *Tree, numstates int, jobs <-chan int, results chan<- ParsResult)

                                                                                  CalcSankParsWork ...

                                                                                  func CalcSliceIntDifference

                                                                                  func CalcSliceIntDifference(a, b []int) []int

                                                                                    CalcSliceIntDifference calculate the difference (set) between two int slices

                                                                                    func CalcSliceIntDifferenceInt

                                                                                    func CalcSliceIntDifferenceInt(a, b []int) int

                                                                                      CalcSliceIntDifferenceInt calculate the size of the difference (set) between two int slices

                                                                                      func CalcStochMap

                                                                                      func CalcStochMap(x *DiscreteModel, tree *Tree, patternval []float64, time bool, from int, to int) (retstates map[*Node][][]float64)

                                                                                        CalcStochMap this has been taken from the multistate code so make sure it works for others

                                                                                        func CalcSupLikeNode

                                                                                        func CalcSupLikeNode(nd *Node, model *DiscreteModel, site int)

                                                                                        func CalcSupLikeWork

                                                                                        func CalcSupLikeWork(t *Tree, x *DiscreteModel, jobs <-chan int, results chan<- LikeSupResult)

                                                                                          CalcLikeWork this is the worker

                                                                                          func CompareTreeToBiparts

                                                                                          func CompareTreeToBiparts(bps []Bipart, comptreebps []Bipart, workers int, mapints map[int]string, verbose bool, treeverbose bool)

                                                                                            CompareTreeToBiparts take biparts from a set , comparetreebps, and compre them to another set bps this one is complicated so keep with it

                                                                                            func ConfInt95TF

                                                                                            func ConfInt95TF(nums []float64) (float64, float64)

                                                                                              ConfInt95TF returns 95% conf int t-stat

                                                                                              func EstParsBL

                                                                                              func EstParsBL(t *Tree, numstates int, patternval []float64, totalsites int)

                                                                                                EstParsBL estimate the parsimony branch lengths

                                                                                                func GetEmpiricalBaseFreqs

                                                                                                func GetEmpiricalBaseFreqs(seqs map[string]string) (bf []float64)

                                                                                                  GetEmpiricalBaseFreqs get the empirical base freqs from the seqs

                                                                                                  func GetEmpiricalBaseFreqsMS

                                                                                                  func GetEmpiricalBaseFreqsMS(seqs []MSeq, numstates int) (bf []float64)

                                                                                                    GetEmpiricalBaseFreqsMS get the empirical base freqs from the seqs

                                                                                                    func GetEmpiricalBaseFreqsProt

                                                                                                    func GetEmpiricalBaseFreqsProt(seqs map[string]string) (bf []float64)

                                                                                                      GetEmpiricalBaseFreqsProt get the empirical base freqs from the seqs

                                                                                                      func GetGammaCats

                                                                                                      func GetGammaCats(alpha float64, cats int, median bool) []float64

                                                                                                        GetGammaCats for likelihood calculators

                                                                                                        func GetMap

                                                                                                        func GetMap(numStates int) (charMap map[string][]int)

                                                                                                          GetMap based on states without the MultStateModel struct

                                                                                                          func GetMultMap

                                                                                                          func GetMultMap(numStates int) (charMap map[string][]int)

                                                                                                            GetMultMap based on states without the MultStateModel struct

                                                                                                            func GetNucMap

                                                                                                            func GetNucMap() (charMap map[string][]int)

                                                                                                              GetNucMap get the int map for DNA with ambiguities

                                                                                                              func GetProtMap

                                                                                                              func GetProtMap() (charMap map[string][]int)

                                                                                                                GetProtMap get the int map for DNA with ambiguities

                                                                                                                func GetRevNucMap

                                                                                                                func GetRevNucMap() (charMap map[int]string)

                                                                                                                  GetRevNucMap ...

                                                                                                                  func GetSitePatterns

                                                                                                                  func GetSitePatterns(seqs map[string]string, nsites int, seqnames []string) (patterns map[string][]int,
                                                                                                                  	patternsint map[int]float64, gapsites []int, constant []int, uninformative []int, fullpattern []int)

                                                                                                                    GetSitePatterns return site pattens when the datatype for the alignment is a map[string]string

                                                                                                                    func GetSitePatternsMS

                                                                                                                    func GetSitePatternsMS(seqs []MSeq, charMap map[string][]int, numstates int) (patterns map[string][]int,
                                                                                                                    	patternsint map[int]float64, gapsites []int, constant []int, uninformative []int, fullpattern []int)

                                                                                                                      GetSitePatternsMS return site pattens when the datatype for the alignment is a map[string]string

                                                                                                                      func GetSitePatternsProt

                                                                                                                      func GetSitePatternsProt(seqs map[string]string, nsites int, seqnames []string) (patterns map[string][]int,
                                                                                                                      	patternsint map[int]float64, gapsites []int, constant []int, uninformative []int, fullpattern []int)

                                                                                                                        GetSitePatternsProt return site pattens when the datatype for the alignment is a map[string]string

                                                                                                                        func IntMapDifferenceRet

                                                                                                                        func IntMapDifferenceRet(a, b map[int]bool) []int

                                                                                                                          IntMapDifferenceRet calculate the difference (set) between two int slices

                                                                                                                          func IntMapIntersects

                                                                                                                          func IntMapIntersects(s1 map[int]bool, s2 map[int]bool) (in bool)

                                                                                                                            IntMapIntersects checks to see if the two map[int]bool intersect (in the set sense)

                                                                                                                            func IntMapIntersects2

                                                                                                                            func IntMapIntersects2(s1 map[int]bool, s2 map[int]bool) (in bool)

                                                                                                                              IntMapIntersects2 checks to see if the two map[int]bool intersect (in the set sense) with at least 2 matches

                                                                                                                              func IntMapIntersectsRet

                                                                                                                              func IntMapIntersectsRet(s1, s2 map[int]bool) (r []int)

                                                                                                                                IntMapIntersectsRet checks to see if the two map[int]bool intersect and returns the intersection (in the set sense)

                                                                                                                                func IntMapSetString

                                                                                                                                func IntMapSetString(intmap map[int]bool) (s string)

                                                                                                                                  IntMapSetString get a string for printing off a set

                                                                                                                                  func IntSliceContains

                                                                                                                                  func IntSliceContains(is []int, s int) (rb bool)

                                                                                                                                    IntSliceContains checks to see if the int slice contains an int and returns the bool

                                                                                                                                    func IntSliceIntersects

                                                                                                                                    func IntSliceIntersects(a, b []int) (rb bool)

                                                                                                                                      IntSliceIntersects checks to see whether two int slices intersect

                                                                                                                                      func Log1exp

                                                                                                                                      func Log1exp(x float64) float64

                                                                                                                                        Log1exp returns log(0+e^x) when e^x is in range

                                                                                                                                        func LogFact

                                                                                                                                        func LogFact(k float64) float64

                                                                                                                                          LogFact calculate the log factorial - this is based on Stirling's approx and is faster than LogFactorial

                                                                                                                                          func LogFactorial

                                                                                                                                          func LogFactorial(val int) (x float64)

                                                                                                                                            LogFactorial slow method to calculate log factorial log(1) + log(2) + ... + log(n)

                                                                                                                                            func MapContinuous

                                                                                                                                            func MapContinuous(t *Tree, traitfl string)

                                                                                                                                              MapContinuous maps the traits from a file to the tips of a tree and initializes slices of the same length for the internal nodes

                                                                                                                                              func MaxF

                                                                                                                                              func MaxF(n []float64) float64

                                                                                                                                                MaxF max

                                                                                                                                                func MedianF

                                                                                                                                                func MedianF(n []float64) float64

                                                                                                                                                  MedianF calculate the "median" value

                                                                                                                                                  func MinF

                                                                                                                                                  func MinF(n []float64) float64

                                                                                                                                                    MinF max

                                                                                                                                                    func NNIMoves

                                                                                                                                                    func NNIMoves(tr *Tree) [][]*Node

                                                                                                                                                      NNIMoves looks at the root and returns the NNIs

                                                                                                                                                      func NW

                                                                                                                                                      func NW(seqs []Seq, in1 int, in2 int)

                                                                                                                                                        NW toy example, scores are all default

                                                                                                                                                        func NodeNamesSliceIntersects

                                                                                                                                                        func NodeNamesSliceIntersects(a, b []*Node) (rb bool)

                                                                                                                                                          NodeNamesSliceIntersects checks to see whether two node slices intersect by name

                                                                                                                                                          func NodeSliceContains

                                                                                                                                                          func NodeSliceContains(s []*Node, e *Node) bool

                                                                                                                                                            NodeSliceContains tells you whether the e string is in the slice

                                                                                                                                                            func NodeSlicePosition

                                                                                                                                                            func NodeSlicePosition(sl []*Node, nd *Node) (x int)

                                                                                                                                                              NodeSlicePosition take a *[]Node slice and teh get the index of the element node

                                                                                                                                                              func OptimizeAACompSharedRM

                                                                                                                                                              func OptimizeAACompSharedRM(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                              	patternvals []float64, log bool, wks int)

                                                                                                                                                                OptimizeAACompSharedRM optimize GTR base composition but share rate matrix for the different parts

                                                                                                                                                                func OptimizeAACompSharedRMSingleModel

                                                                                                                                                                func OptimizeAACompSharedRMSingleModel(t *Tree, models []*DiscreteModel,
                                                                                                                                                                	nodemodels map[*Node]int, usemodelvals bool, whichmodel int,
                                                                                                                                                                	patternvals []float64, log bool, wks int)

                                                                                                                                                                  OptimizeAACompSharedRMSingleModel optimize AA base comp but share rate matrix for different parts

                                                                                                                                                                  func OptimizeBF

                                                                                                                                                                  func OptimizeBF(t *Tree, x *DiscreteModel, patternvals []float64, log bool, wks int)

                                                                                                                                                                    OptimizeBF optimizing the basefreq model but for a clade

                                                                                                                                                                    func OptimizeBFDNARMSubClade

                                                                                                                                                                    func OptimizeBFDNARMSubClade(t *Tree, n *Node, excl bool, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                      OptimizeBFDNARMSubClade optimizing the basefreq model but for a subclade

                                                                                                                                                                      func OptimizeBFSubClade

                                                                                                                                                                      func OptimizeBFSubClade(t *Tree, n *Node, excl bool, x *DiscreteModel, patternvals []float64, log bool, wks int)

                                                                                                                                                                        OptimizeBFSubClade optimizing the basefreq model but for a subclade

                                                                                                                                                                        func OptimizeBL

                                                                                                                                                                        func OptimizeBL(nd *Node, t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                          OptimizeBL This uses the standard gonum optimizers. Not great.

                                                                                                                                                                          func OptimizeBLNR

                                                                                                                                                                          func OptimizeBLNR(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                            OptimizeBLNR Newton-Raphson for each branch. Does 4 passes

                                                                                                                                                                            func OptimizeBLNRGN

                                                                                                                                                                            func OptimizeBLNRGN(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                            func OptimizeBLNRMult

                                                                                                                                                                            func OptimizeBLNRMult(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, patternvals []float64, wks int)

                                                                                                                                                                              OptimizeBLNRMult Newton-Raphson for each branch. Does 4 passes

                                                                                                                                                                              func OptimizeBLS

                                                                                                                                                                              func OptimizeBLS(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                                OptimizeBLS optimize all branch lengths

                                                                                                                                                                                func OptimizeBLSCLock

                                                                                                                                                                                func OptimizeBLSCLock(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                                  OptimizeBLSCLock optimize all branch lengths assuming a clock

                                                                                                                                                                                  func OptimizeBLSCLockNL

                                                                                                                                                                                  func OptimizeBLSCLockNL(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                                    OptimizeBLSCLockNL optimize all branch lengths assuming a clock

                                                                                                                                                                                    func OptimizeBLSMul

                                                                                                                                                                                    func OptimizeBLSMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, patternvals []float64, wks int) float64

                                                                                                                                                                                      OptimizeBLSMul optimize all branch lengths

                                                                                                                                                                                      func OptimizeBLSNL

                                                                                                                                                                                      func OptimizeBLSNL(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                                        OptimizeBLS optimize all branch lengths

                                                                                                                                                                                        func OptimizeGTRBPDNAMul

                                                                                                                                                                                        func OptimizeGTRBPDNAMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, usemodelvals bool,
                                                                                                                                                                                        	patternvals []float64, log bool, wks int)

                                                                                                                                                                                          OptimizeGTRBPDNAMul optimize GTR and base composition for the different parts

                                                                                                                                                                                          func OptimizeGTRDNA

                                                                                                                                                                                          func OptimizeGTRDNA(t *Tree, x *DiscreteModel, patternvals []float64,
                                                                                                                                                                                          	sup bool, wks int) []float64

                                                                                                                                                                                            OptimizeGTRDNA optimize GTR

                                                                                                                                                                                            func OptimizeGTRDNACompSharedRM

                                                                                                                                                                                            func OptimizeGTRDNACompSharedRM(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                            	usemodelvals bool, patternvals []float64, log bool, wks int)

                                                                                                                                                                                              OptimizeGTRDNACompSharedRM optimize GTR base composition but share rate matrix for the different parts

                                                                                                                                                                                              func OptimizeGTRDNACompSharedRMSingleModel

                                                                                                                                                                                              func OptimizeGTRDNACompSharedRMSingleModel(t *Tree, models []*DiscreteModel,
                                                                                                                                                                                              	nodemodels map[*Node]int, usemodelvals bool, whichmodel int,
                                                                                                                                                                                              	patternvals []float64, log bool, wks int)

                                                                                                                                                                                                OptimizeGTRDNACompSharedRMSingleModel optimize GTR base composition but share rate matrix for the different parts

                                                                                                                                                                                                you send an int that will identify which model can be adjusted and only that one will be
                                                                                                                                                                                                

                                                                                                                                                                                                func OptimizeGTRDNACompSharedRMSubClade

                                                                                                                                                                                                func OptimizeGTRDNACompSharedRMSubClade(t *Tree, n *Node, excl bool, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                                	usemodelvals bool, patternvals []float64, wks int)

                                                                                                                                                                                                  OptimizeGTRDNACompSharedRMSubClade optimize GTR base composition but share rate matrix for the different parts

                                                                                                                                                                                                  func OptimizeGTRDNAMul

                                                                                                                                                                                                  func OptimizeGTRDNAMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, patternvals []float64, wks int)

                                                                                                                                                                                                    OptimizeGTRDNAMul optimize GTR

                                                                                                                                                                                                    func OptimizeGTRDNASubClade

                                                                                                                                                                                                    func OptimizeGTRDNASubClade(t *Tree, n *Node, excl bool, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                                                      OptimizeGTRDNASubClade optimizing the GTR model but for a subclade

                                                                                                                                                                                                      func OptimizeGamma

                                                                                                                                                                                                      func OptimizeGamma(t *Tree, x *DiscreteModel, patternvals []float64, log bool, wks int)

                                                                                                                                                                                                        OptimizeGamma ...

                                                                                                                                                                                                        func OptimizeGammaAndBL

                                                                                                                                                                                                        func OptimizeGammaAndBL(t *Tree, x *DiscreteModel, patternvals []float64, log bool, wks int)

                                                                                                                                                                                                          OptimizeGammaAndBL ...

                                                                                                                                                                                                          func OptimizeGammaAndBLMult

                                                                                                                                                                                                          func OptimizeGammaAndBLMult(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                                          	patternvals []float64, log bool, wks int)

                                                                                                                                                                                                          func OptimizeGammaBLS

                                                                                                                                                                                                          func OptimizeGammaBLS(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                                                            OptimizeGammaBLS optimize all branch lengths

                                                                                                                                                                                                            func OptimizeGammaBLSMult

                                                                                                                                                                                                            func OptimizeGammaBLSMult(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, patternvals []float64, wks int)

                                                                                                                                                                                                              OptimizeGammaBLS optimize all branch lengths

                                                                                                                                                                                                              func OptimizeGammaBLSNL

                                                                                                                                                                                                              func OptimizeGammaBLSNL(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                                                              func OptimizeGammaBLSNLMult

                                                                                                                                                                                                              func OptimizeGammaBLSNLMult(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                                              	patternvals []float64, log bool, wks int)

                                                                                                                                                                                                              func OptimizeGammaMult

                                                                                                                                                                                                              func OptimizeGammaMult(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                                              	patternvals []float64, log bool, wks int)

                                                                                                                                                                                                              func OptimizeMKMS

                                                                                                                                                                                                              func OptimizeMKMS(t *Tree, x *DiscreteModel, startv float64, patternvals []float64, sym bool, wks int)

                                                                                                                                                                                                                OptimizeMKMS optimize GTR

                                                                                                                                                                                                                symmetrical and scale the last rate to 1
                                                                                                                                                                                                                

                                                                                                                                                                                                                func OptimizeMS1R

                                                                                                                                                                                                                func OptimizeMS1R(t *Tree, x *DiscreteModel, patternvals []float64, wks int)

                                                                                                                                                                                                                  OptimizeMS1R ... hold over from other things, probably change this is for specific multistate models

                                                                                                                                                                                                                  func OptimizeSharedGammaAndBLMult

                                                                                                                                                                                                                  func OptimizeSharedGammaAndBLMult(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                                                  	patternvals []float64, log bool, wks int)

                                                                                                                                                                                                                  func OutputEdges

                                                                                                                                                                                                                  func OutputEdges(mapints map[int]string, bps []Bipart, ntrees int, verb bool)

                                                                                                                                                                                                                    OutputEdges just print the edges mapints are int to string names for the taxa bps list of biparts ntrees number of trees

                                                                                                                                                                                                                    func PCalcLike

                                                                                                                                                                                                                    func PCalcLike(t *Tree, x *DiscreteModel, nsites int, wks int) (fl float64)

                                                                                                                                                                                                                      PCalcLike parallel calculate likelihood

                                                                                                                                                                                                                      func PCalcLikePatterns

                                                                                                                                                                                                                      func PCalcLikePatterns(t *Tree, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                        PCalcLikePatterns parallel caclulation of likelihood with patterns

                                                                                                                                                                                                                        func PCalcLikePatternsGamma

                                                                                                                                                                                                                        func PCalcLikePatternsGamma(t *Tree, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                          PCalcLikePatternsGamma parallel caclulation of likelihood with patterns with gamma

                                                                                                                                                                                                                          func PCalcLikePatternsGammaMul

                                                                                                                                                                                                                          func PCalcLikePatternsGammaMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                                                          	patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                            PCalcLikePatternsGammaMul parallel caclulation of likelihood with patterns with gamma

                                                                                                                                                                                                                            func PCalcLikePatternsMarked

                                                                                                                                                                                                                            func PCalcLikePatternsMarked(t *Tree, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                              PCalcLikePatternsMarked parallel likelihood caclulation with patterns and just update the values

                                                                                                                                                                                                                              func PCalcLikePatternsMarkedGamma

                                                                                                                                                                                                                              func PCalcLikePatternsMarkedGamma(t *Tree, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                PCalcLikePatternsMarkedGamma parallel likelihood caclulation with patterns and just update the values

                                                                                                                                                                                                                                func PCalcLikePatternsMarkedMul

                                                                                                                                                                                                                                func PCalcLikePatternsMarkedMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                  PCalcLikePatternsMarkedMul parallel likelihood caclulation with patterns and just update the values

                                                                                                                                                                                                                                  func PCalcLikePatternsMul

                                                                                                                                                                                                                                  func PCalcLikePatternsMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                                                                  	patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                    PCalcLikePatternsMul parallel caclulation of likelihood with patterns

                                                                                                                                                                                                                                    func PCalcLikePatternsMulSubClade

                                                                                                                                                                                                                                    func PCalcLikePatternsMulSubClade(t *Tree, n *Node, excl bool, models []*DiscreteModel,
                                                                                                                                                                                                                                    	nodemodels map[*Node]int, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                      PCalcLikePatternsMulSubClade parallel log likeliohood calculation including patterns

                                                                                                                                                                                                                                      func PCalcLikePatternsSubClade

                                                                                                                                                                                                                                      func PCalcLikePatternsSubClade(t *Tree, n *Node, excl bool, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                        PCalcLikePatternsSubClade parallel log likeliohood calculation including patterns

                                                                                                                                                                                                                                        func PCalcLogLike

                                                                                                                                                                                                                                        func PCalcLogLike(t *Tree, x *DiscreteModel, nsites int, wks int) (fl float64)

                                                                                                                                                                                                                                          PCalcLogLike this will calculate log like in parallel

                                                                                                                                                                                                                                          func PCalcLogLikeBack

                                                                                                                                                                                                                                          func PCalcLogLikeBack(t *Tree, n *Node, x *DiscreteModel, nsites int, wks int) (fl float64)

                                                                                                                                                                                                                                            PCalcLogLikeBack a bit of a shortcut. Could do better, but walks back from the n node to the root

                                                                                                                                                                                                                                            func PCalcLogLikeMarked

                                                                                                                                                                                                                                            func PCalcLogLikeMarked(t *Tree, x *DiscreteModel, nsites int, wks int) (fl float64)

                                                                                                                                                                                                                                              PCalcLogLikeMarked parallel calculation of loglike with just updating

                                                                                                                                                                                                                                              func PCalcLogLikePatterns

                                                                                                                                                                                                                                              func PCalcLogLikePatterns(t *Tree, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                                PCalcLogLikePatterns parallel log likeliohood calculation including patterns

                                                                                                                                                                                                                                                func PCalcLogLikePatternsGamma

                                                                                                                                                                                                                                                func PCalcLogLikePatternsGamma(t *Tree, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                                  PCalcLogLikePatternsGamma parallel log likeliohood calculation including patterns

                                                                                                                                                                                                                                                  func PCalcLogLikePatternsGammaMul

                                                                                                                                                                                                                                                  func PCalcLogLikePatternsGammaMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int,
                                                                                                                                                                                                                                                  	patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                                  func PCalcLogLikePatternsMul

                                                                                                                                                                                                                                                  func PCalcLogLikePatternsMul(t *Tree, models []*DiscreteModel, nodemodels map[*Node]int, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                                    PCalcLogLikePatternsMul ...

                                                                                                                                                                                                                                                    func PCalcLogLikePatternsSubClade

                                                                                                                                                                                                                                                    func PCalcLogLikePatternsSubClade(t *Tree, n *Node, excl bool, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                                      PCalcLogLikePatternsSubClade parallel log likeliohood calculation including patterns

                                                                                                                                                                                                                                                      func PCalcRFDistancesPartial

                                                                                                                                                                                                                                                      func PCalcRFDistancesPartial(bpts map[int][]int, bps []Bipart, jobs <-chan []int, results chan<- []int)

                                                                                                                                                                                                                                                        PCalcRFDistancesPartial calculates the partial rf, bpts is the tree index, bipart list, bps is the list of biparts

                                                                                                                                                                                                                                                        func PCalcRFDistancesPartialWeighted

                                                                                                                                                                                                                                                        func PCalcRFDistancesPartialWeighted(bpts map[int][]int, tippenalty bool, bps []Bipart, jobs <-chan []int, results chan<- Rfwresult)

                                                                                                                                                                                                                                                          PCalcRFDistancesPartialWeighted includes the branch lengths

                                                                                                                                                                                                                                                          func PCalcSankParsPatterns

                                                                                                                                                                                                                                                          func PCalcSankParsPatterns(t *Tree, numstates int, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                                            PCalcSankParsPatterns parallel caclulation of parsimony costs with patterns

                                                                                                                                                                                                                                                            func PCalcSliceIntDifferenceInt

                                                                                                                                                                                                                                                            func PCalcSliceIntDifferenceInt(bpts map[int][]int, jobs <-chan []int, results chan<- []int)

                                                                                                                                                                                                                                                              PCalcSliceIntDifferenceInt calculate the size of the difference (set) between two int slices in parallel used for: RF distance where the bpts is the tree index -> bipart index list map

                                                                                                                                                                                                                                                              func PCalcSupLikePatterns

                                                                                                                                                                                                                                                              func PCalcSupLikePatterns(t *Tree, x *DiscreteModel, patternval []float64, wks int) (fl float64)

                                                                                                                                                                                                                                                              func PConcordance

                                                                                                                                                                                                                                                              func PConcordance(bps []Bipart, jobs <-chan []int, results chan<- []int)

                                                                                                                                                                                                                                                                PConcordance is similar to the other comparison code but for concordance. The input jobs are the i, j for the bipart comparisons. The results are the i, j, and 0 for not concordant and 1 for concordant

                                                                                                                                                                                                                                                                func PConcordanceTwoSets

                                                                                                                                                                                                                                                                func PConcordanceTwoSets(comp []Bipart, bps []Bipart, jobs <-chan []int, results chan<- []int)

                                                                                                                                                                                                                                                                  PConcordanceTwoSets same as the one above but where there are two sets

                                                                                                                                                                                                                                                                  func PConflicts

                                                                                                                                                                                                                                                                  func PConflicts(bps []Bipart, jobs <-chan []int, results chan<- []int)

                                                                                                                                                                                                                                                                    PConflicts is a parallel conflict check. The slice is sent. The jobs are the two indices to check. The results are the two indicies and an int 1 for conflict 0 for no conflict

                                                                                                                                                                                                                                                                    func PConflictsCompTree

                                                                                                                                                                                                                                                                    func PConflictsCompTree(bps []Bipart, comptreebps []Bipart, jobs <-chan []int, results chan<- []int)

                                                                                                                                                                                                                                                                      PConflictsCompTree is similar to PConflict but the first index refers to the first Bipart slice and the second referts to the second Bipart slice

                                                                                                                                                                                                                                                                      func PNW

                                                                                                                                                                                                                                                                      func PNW(seqs []Seq, jobs <-chan []int, results chan<- float32)

                                                                                                                                                                                                                                                                        PNW NW but parallel

                                                                                                                                                                                                                                                                        func PreparePatternVecs

                                                                                                                                                                                                                                                                        func PreparePatternVecs(t *Tree, patternsint map[int]float64, seqs map[string]string) (patternval []float64, patternvec []int)

                                                                                                                                                                                                                                                                          PreparePatternVecs for tree calculations

                                                                                                                                                                                                                                                                          func PreparePatternVecsMS

                                                                                                                                                                                                                                                                          func PreparePatternVecsMS(t *Tree, patternsint map[int]float64, seqs map[string][]string,
                                                                                                                                                                                                                                                                          	charMap map[string][]int, numstates int) (patternval []float64, patternvec []int)

                                                                                                                                                                                                                                                                            PreparePatternVecsMS for tree calculations

                                                                                                                                                                                                                                                                            func PreparePatternVecsProt

                                                                                                                                                                                                                                                                            func PreparePatternVecsProt(t *Tree, patternsint map[int]float64, seqs map[string]string) (patternval []float64, patternvec []int)

                                                                                                                                                                                                                                                                              PreparePatternVecsProt for tree calculations

                                                                                                                                                                                                                                                                              func RTMultconditionals

                                                                                                                                                                                                                                                                              func RTMultconditionals(models []*DiscreteModel, nodemodels map[*Node]int, node *Node, patternval []float64)

                                                                                                                                                                                                                                                                                RTMultconditionals ...

                                                                                                                                                                                                                                                                                func RTconditionals

                                                                                                                                                                                                                                                                                func RTconditionals(x *DiscreteModel, node *Node, patternval []float64)

                                                                                                                                                                                                                                                                                  RTconditionals tipconds calculated to the rt (including BL)

                                                                                                                                                                                                                                                                                  func RVMultconditionals

                                                                                                                                                                                                                                                                                  func RVMultconditionals(models []*DiscreteModel, nodemodels map[*Node]int, node *Node, patternval []float64)

                                                                                                                                                                                                                                                                                    RVMultconditionals ...

                                                                                                                                                                                                                                                                                    func RVTPconditionals

                                                                                                                                                                                                                                                                                    func RVTPconditionals(x *DiscreteModel, node *Node, patternval []float64)

                                                                                                                                                                                                                                                                                      RVTPconditionals ...

                                                                                                                                                                                                                                                                                      func RVconditionals

                                                                                                                                                                                                                                                                                      func RVconditionals(x *DiscreteModel, node *Node, patternval []float64)

                                                                                                                                                                                                                                                                                        RVconditionals take par RvTpConds and put get bl

                                                                                                                                                                                                                                                                                        func ReadLine

                                                                                                                                                                                                                                                                                        func ReadLine(path string) (ln []string)

                                                                                                                                                                                                                                                                                          ReadLine is like the Python readline() and readlines()

                                                                                                                                                                                                                                                                                          func ReadPatternsMSeqsFromFile

                                                                                                                                                                                                                                                                                          func ReadPatternsMSeqsFromFile(sfn string) (seqs map[string][]string,
                                                                                                                                                                                                                                                                                          	patternsint map[int]float64, nsites int, bf []float64, numstates int)

                                                                                                                                                                                                                                                                                            ReadPatternsMSeqsFromFile return the seqs and patternsint

                                                                                                                                                                                                                                                                                            func ReadPatternsSeqsFromFile

                                                                                                                                                                                                                                                                                            func ReadPatternsSeqsFromFile(sfn string, nucleotide bool) (seqs map[string]string, patternsint map[int]float64, nsites int, bf []float64)

                                                                                                                                                                                                                                                                                              ReadPatternsSeqsFromFile return the seqs and patternsint

                                                                                                                                                                                                                                                                                              func Reroot

                                                                                                                                                                                                                                                                                              func Reroot(inroot *Node, tr *Tree)

                                                                                                                                                                                                                                                                                                Reroot basic reroot function

                                                                                                                                                                                                                                                                                                func Round

                                                                                                                                                                                                                                                                                                func Round(val float64, roundOn float64, places int) (newVal float64)

                                                                                                                                                                                                                                                                                                  Round to the nearest place probably val=num, roundOn = 0.5 places = 5

                                                                                                                                                                                                                                                                                                  func SetHeights

                                                                                                                                                                                                                                                                                                  func SetHeights(tree *Tree)

                                                                                                                                                                                                                                                                                                    SetHeights set tree height

                                                                                                                                                                                                                                                                                                    func StochasticNNI

                                                                                                                                                                                                                                                                                                    func StochasticNNI()

                                                                                                                                                                                                                                                                                                      StochasticNNI should make NNI moves

                                                                                                                                                                                                                                                                                                      func StringSliceContains

                                                                                                                                                                                                                                                                                                      func StringSliceContains(s []string, e string) bool

                                                                                                                                                                                                                                                                                                        StringSliceContains tells you whether the e string is in the slice

                                                                                                                                                                                                                                                                                                        func SumFloatVec

                                                                                                                                                                                                                                                                                                        func SumFloatVec(x []float64) (s float64)

                                                                                                                                                                                                                                                                                                          SumFloatVec sum the float vectors

                                                                                                                                                                                                                                                                                                          func SumLogExp

                                                                                                                                                                                                                                                                                                          func SumLogExp(a, b float64) float64

                                                                                                                                                                                                                                                                                                            SumLogExp sum log of exps

                                                                                                                                                                                                                                                                                                            func SwapBranch

                                                                                                                                                                                                                                                                                                            func SwapBranch(nd1 *Node, nd2 *Node) bool

                                                                                                                                                                                                                                                                                                              SwapBranch will to get the branches that would be NNIs, use the function and then send the relevant nodes here

                                                                                                                                                                                                                                                                                                              func TPconditionals

                                                                                                                                                                                                                                                                                                              func TPconditionals(x *DiscreteModel, node *Node, patternval []float64)

                                                                                                                                                                                                                                                                                                                TPconditionals regular tip conditionals

                                                                                                                                                                                                                                                                                                                func TritomyRoot

                                                                                                                                                                                                                                                                                                                func TritomyRoot(tr *Tree)

                                                                                                                                                                                                                                                                                                                  TritomyRoot makes the root a tritomy

                                                                                                                                                                                                                                                                                                                  Types

                                                                                                                                                                                                                                                                                                                  type Bipart

                                                                                                                                                                                                                                                                                                                  type Bipart struct {
                                                                                                                                                                                                                                                                                                                  	Lt          map[int]bool
                                                                                                                                                                                                                                                                                                                  	Rt          map[int]bool
                                                                                                                                                                                                                                                                                                                  	Ct          int           // counts
                                                                                                                                                                                                                                                                                                                  	TreeIndices []int         // index of which trees this is in
                                                                                                                                                                                                                                                                                                                  	Nds         []*Node       // nodes associated with the bipart
                                                                                                                                                                                                                                                                                                                  	NdsM        map[int]*Node // nodes associated with the bipart by treeindex
                                                                                                                                                                                                                                                                                                                  	Index       int           // just a unique id
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    Bipart are represented as map[int]bools, one for the left and one for the right

                                                                                                                                                                                                                                                                                                                    func (Bipart) CompatibleWith

                                                                                                                                                                                                                                                                                                                    func (b Bipart) CompatibleWith(ib Bipart) (con bool)

                                                                                                                                                                                                                                                                                                                      CompatibleWith checks that it isn't conflicting but can be nested

                                                                                                                                                                                                                                                                                                                      func (Bipart) ConcordantWith

                                                                                                                                                                                                                                                                                                                      func (b Bipart) ConcordantWith(ib Bipart) (con bool)

                                                                                                                                                                                                                                                                                                                        ConcordantWith tests whether something is concordant (not conflicting or nested, etc)

                                                                                                                                                                                                                                                                                                                        func (Bipart) ConflictsWith

                                                                                                                                                                                                                                                                                                                        func (b Bipart) ConflictsWith(ib Bipart) (con bool)

                                                                                                                                                                                                                                                                                                                          ConflictsWith checks whether two biparts conflict

                                                                                                                                                                                                                                                                                                                          func (Bipart) Equals

                                                                                                                                                                                                                                                                                                                          func (b Bipart) Equals(ib Bipart) (eq bool)

                                                                                                                                                                                                                                                                                                                            Equals trying to be faster

                                                                                                                                                                                                                                                                                                                            func (Bipart) NewickWithNames

                                                                                                                                                                                                                                                                                                                            func (b Bipart) NewickWithNames(nmmap map[int]string) (ret string)

                                                                                                                                                                                                                                                                                                                              NewickWithNames does similar things to StringWithNames but sends a newick back

                                                                                                                                                                                                                                                                                                                              func (Bipart) StringWithNames

                                                                                                                                                                                                                                                                                                                              func (b Bipart) StringWithNames(nmmap map[int]string) (ret string)

                                                                                                                                                                                                                                                                                                                                StringWithNames converts the ints to the the strings from nmmap

                                                                                                                                                                                                                                                                                                                                type DNAModel

                                                                                                                                                                                                                                                                                                                                type DNAModel struct {
                                                                                                                                                                                                                                                                                                                                	M DiscreteModel
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                func NewDNAModel

                                                                                                                                                                                                                                                                                                                                func NewDNAModel() *DNAModel

                                                                                                                                                                                                                                                                                                                                func (*DNAModel) DeepCopyDNAModel

                                                                                                                                                                                                                                                                                                                                func (d *DNAModel) DeepCopyDNAModel() *DNAModel

                                                                                                                                                                                                                                                                                                                                  DeepCopyDNAModel ...

                                                                                                                                                                                                                                                                                                                                  type DataType

                                                                                                                                                                                                                                                                                                                                  type DataType string

                                                                                                                                                                                                                                                                                                                                    DataType type for alphabet

                                                                                                                                                                                                                                                                                                                                    type DiscreteModel

                                                                                                                                                                                                                                                                                                                                    type DiscreteModel struct {
                                                                                                                                                                                                                                                                                                                                    	Alph      DataType  // nuc, prot or multstate model
                                                                                                                                                                                                                                                                                                                                    	BF        []float64 // base frequencies, order is A,C,G,T or A,R,N,D,C,Q,E,G,H,I,L,K,M,F,P,S,T,W,Y,V
                                                                                                                                                                                                                                                                                                                                    	MBF       []float64 // model base frequencies
                                                                                                                                                                                                                                                                                                                                    	EBF       []float64 // empirical base freqs
                                                                                                                                                                                                                                                                                                                                    	R         *mat.Dense
                                                                                                                                                                                                                                                                                                                                    	Q         *mat.Dense // common use
                                                                                                                                                                                                                                                                                                                                    	Ex        string     // PAML-formatted exchangeabilities for Prot models
                                                                                                                                                                                                                                                                                                                                    	CharMap   map[string][]int
                                                                                                                                                                                                                                                                                                                                    	NumStates int
                                                                                                                                                                                                                                                                                                                                    	//sync.RWMutex
                                                                                                                                                                                                                                                                                                                                    	Ps  map[float64]*mat.Dense
                                                                                                                                                                                                                                                                                                                                    	PsL map[float64]*mat.Dense
                                                                                                                                                                                                                                                                                                                                    	X   *mat.Dense
                                                                                                                                                                                                                                                                                                                                    	P   mat.Dense
                                                                                                                                                                                                                                                                                                                                    	//for decomposing
                                                                                                                                                                                                                                                                                                                                    	QS         *mat.Dense
                                                                                                                                                                                                                                                                                                                                    	EigenVals  []float64  // to be exponentiated
                                                                                                                                                                                                                                                                                                                                    	EigenVecs  *mat.Dense //
                                                                                                                                                                                                                                                                                                                                    	EigenVecsI *mat.Dense
                                                                                                                                                                                                                                                                                                                                    	X1         *mat.Dense
                                                                                                                                                                                                                                                                                                                                    	X2         *mat.Dense
                                                                                                                                                                                                                                                                                                                                    	GammaAlpha float64
                                                                                                                                                                                                                                                                                                                                    	GammaNCats int
                                                                                                                                                                                                                                                                                                                                    	GammaCats  []float64
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      DiscreteModel overall model struct

                                                                                                                                                                                                                                                                                                                                      func NewDiscreteModel

                                                                                                                                                                                                                                                                                                                                      func NewDiscreteModel() *DiscreteModel

                                                                                                                                                                                                                                                                                                                                        NewDiscreteModel get new model pointer

                                                                                                                                                                                                                                                                                                                                        func (*DiscreteModel) DecomposeQ

                                                                                                                                                                                                                                                                                                                                        func (d *DiscreteModel) DecomposeQ()

                                                                                                                                                                                                                                                                                                                                          DecomposeQ this is just for NR optimization for branch lengths

                                                                                                                                                                                                                                                                                                                                          func (*DiscreteModel) DeepCopyDiscreteModel

                                                                                                                                                                                                                                                                                                                                          func (d *DiscreteModel) DeepCopyDiscreteModel() *DiscreteModel

                                                                                                                                                                                                                                                                                                                                          func (*DiscreteModel) EmptyPDict

                                                                                                                                                                                                                                                                                                                                          func (d *DiscreteModel) EmptyPDict()

                                                                                                                                                                                                                                                                                                                                            EmptyPDict save memory perhaps?

                                                                                                                                                                                                                                                                                                                                            func (*DiscreteModel) EmptyPLDict

                                                                                                                                                                                                                                                                                                                                            func (d *DiscreteModel) EmptyPLDict()

                                                                                                                                                                                                                                                                                                                                              EmptyPLDict the logged one

                                                                                                                                                                                                                                                                                                                                              func (*DiscreteModel) ExpValue

                                                                                                                                                                                                                                                                                                                                              func (d *DiscreteModel) ExpValue(iv []float64, blen float64)

                                                                                                                                                                                                                                                                                                                                                ExpValue used for the matrix exponential

                                                                                                                                                                                                                                                                                                                                                func (*DiscreteModel) ExpValueFirstD

                                                                                                                                                                                                                                                                                                                                                func (d *DiscreteModel) ExpValueFirstD(blen float64) (x *mat.Dense)

                                                                                                                                                                                                                                                                                                                                                  ExpValueFirstD get the first derivaite for NR

                                                                                                                                                                                                                                                                                                                                                  func (*DiscreteModel) ExpValueSecondD

                                                                                                                                                                                                                                                                                                                                                  func (d *DiscreteModel) ExpValueSecondD(blen float64) (x *mat.Dense)

                                                                                                                                                                                                                                                                                                                                                    ExpValueSecondD get the second derivaite for NR

                                                                                                                                                                                                                                                                                                                                                    func (*DiscreteModel) GetBF

                                                                                                                                                                                                                                                                                                                                                    func (d *DiscreteModel) GetBF() []float64

                                                                                                                                                                                                                                                                                                                                                      GetBF return the base frequencies

                                                                                                                                                                                                                                                                                                                                                      func (*DiscreteModel) GetCharMap

                                                                                                                                                                                                                                                                                                                                                      func (d *DiscreteModel) GetCharMap() map[string][]int

                                                                                                                                                                                                                                                                                                                                                        GetCharMap get the int map for states with ambiguities

                                                                                                                                                                                                                                                                                                                                                        func (*DiscreteModel) GetNumStates

                                                                                                                                                                                                                                                                                                                                                        func (d *DiscreteModel) GetNumStates() int

                                                                                                                                                                                                                                                                                                                                                          GetNumStates return the number of states

                                                                                                                                                                                                                                                                                                                                                          func (*DiscreteModel) GetPCalc

                                                                                                                                                                                                                                                                                                                                                          func (d *DiscreteModel) GetPCalc(blen float64) *mat.Dense

                                                                                                                                                                                                                                                                                                                                                            GetPCalc calculate P matrix

                                                                                                                                                                                                                                                                                                                                                            func (*DiscreteModel) GetPMap

                                                                                                                                                                                                                                                                                                                                                            func (d *DiscreteModel) GetPMap(blen float64) *mat.Dense

                                                                                                                                                                                                                                                                                                                                                              GetPMap get the Ps from the dictionary

                                                                                                                                                                                                                                                                                                                                                              func (*DiscreteModel) GetPMapLogged

                                                                                                                                                                                                                                                                                                                                                              func (d *DiscreteModel) GetPMapLogged(blen float64) *mat.Dense

                                                                                                                                                                                                                                                                                                                                                                GetPMapLogged get the Ps from the dictionary

                                                                                                                                                                                                                                                                                                                                                                func (*DiscreteModel) GetStochMapMatrices

                                                                                                                                                                                                                                                                                                                                                                func (d *DiscreteModel) GetStochMapMatrices(dur float64, from int, to int) (summed *mat.Dense, summedR *mat.Dense)

                                                                                                                                                                                                                                                                                                                                                                  GetStochMapMatrices return matrices for stochastic mapping

                                                                                                                                                                                                                                                                                                                                                                  func (*DiscreteModel) SetBaseFreqs

                                                                                                                                                                                                                                                                                                                                                                  func (d *DiscreteModel) SetBaseFreqs(basefreq []float64)

                                                                                                                                                                                                                                                                                                                                                                    SetBaseFreqs needs to be done before doing SetupQGTR

                                                                                                                                                                                                                                                                                                                                                                    func (*DiscreteModel) SetEmpiricalBF

                                                                                                                                                                                                                                                                                                                                                                    func (d *DiscreteModel) SetEmpiricalBF()

                                                                                                                                                                                                                                                                                                                                                                      SetEmpiricalBF set all to empirical

                                                                                                                                                                                                                                                                                                                                                                      func (*DiscreteModel) SetEqualBF

                                                                                                                                                                                                                                                                                                                                                                      func (d *DiscreteModel) SetEqualBF()

                                                                                                                                                                                                                                                                                                                                                                        SetEqualBF set all state frequencies equal

                                                                                                                                                                                                                                                                                                                                                                        func (*DiscreteModel) SetModelBF

                                                                                                                                                                                                                                                                                                                                                                        func (d *DiscreteModel) SetModelBF()

                                                                                                                                                                                                                                                                                                                                                                          SetModelBF set all to frequencies from empirical model

                                                                                                                                                                                                                                                                                                                                                                          func (*DiscreteModel) SetP

                                                                                                                                                                                                                                                                                                                                                                          func (d *DiscreteModel) SetP(blen float64)

                                                                                                                                                                                                                                                                                                                                                                            SetP use the standard spectral decom

                                                                                                                                                                                                                                                                                                                                                                            func (*DiscreteModel) SetPSimple

                                                                                                                                                                                                                                                                                                                                                                            func (d *DiscreteModel) SetPSimple(blen float64)

                                                                                                                                                                                                                                                                                                                                                                              SetPSimple use the gonum matrixexp (seems faster)

                                                                                                                                                                                                                                                                                                                                                                              func (*DiscreteModel) SetRateMatrix

                                                                                                                                                                                                                                                                                                                                                                              func (d *DiscreteModel) SetRateMatrix(params []float64)

                                                                                                                                                                                                                                                                                                                                                                                SetRateMatrix length is (((numstates*numstates)-numstates)/2) - 1 or (numstates * numstates) - numstates this is for scaled branch lengths and matrices CHANGE THIS TO UNSCALED

                                                                                                                                                                                                                                                                                                                                                                                func (*DiscreteModel) SetScaledRateMatrix

                                                                                                                                                                                                                                                                                                                                                                                func (d *DiscreteModel) SetScaledRateMatrix(params []float64, sym bool)

                                                                                                                                                                                                                                                                                                                                                                                  SetScaledRateMatrix needs to be done before doing SetupQGTR just send along the rates and this will make them the whole matrix the scaled is that this is assuming that the last rate is 1 THIS IS THE SAME? AS SETRATEMATRIX?

                                                                                                                                                                                                                                                                                                                                                                                  func (*DiscreteModel) SetupQGTR

                                                                                                                                                                                                                                                                                                                                                                                  func (d *DiscreteModel) SetupQGTR()

                                                                                                                                                                                                                                                                                                                                                                                    SetupQGTR sets up scaled GTR for (mainly) Could also be used to estimate PROTGTR but that's a bad idea

                                                                                                                                                                                                                                                                                                                                                                                    func (*DiscreteModel) SetupQJC

                                                                                                                                                                                                                                                                                                                                                                                    func (d *DiscreteModel) SetupQJC()

                                                                                                                                                                                                                                                                                                                                                                                      SetupQJC setup Q matrix

                                                                                                                                                                                                                                                                                                                                                                                      This is scaled so that change is reflected in the branch lengths
                                                                                                                                                                                                                                                                                                                                                                                      You don't need to use the SetScaledRateMatrix
                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                      func (*DiscreteModel) SetupQJC1Rate

                                                                                                                                                                                                                                                                                                                                                                                      func (d *DiscreteModel) SetupQJC1Rate(rt float64)

                                                                                                                                                                                                                                                                                                                                                                                        SetupQJC1Rate setup Q matrix with one rate, probably for anc multi state

                                                                                                                                                                                                                                                                                                                                                                                        These are unscaled so the branch lengths are going to be time or something else
                                                                                                                                                                                                                                                                                                                                                                                        and not relative to these rates
                                                                                                                                                                                                                                                                                                                                                                                        Will take BF from something else
                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                        func (*DiscreteModel) SetupQMk

                                                                                                                                                                                                                                                                                                                                                                                        func (d *DiscreteModel) SetupQMk(rt []float64, sym bool)

                                                                                                                                                                                                                                                                                                                                                                                          SetupQMk setup Q matrix

                                                                                                                                                                                                                                                                                                                                                                                          This is unscaled (so the branch lengths are going to be proportion to some other change
                                                                                                                                                                                                                                                                                                                                                                                          and not to these branch lengths)
                                                                                                                                                                                                                                                                                                                                                                                          Will take the BF from something else
                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                          type LikeFunction

                                                                                                                                                                                                                                                                                                                                                                                          type LikeFunction struct {
                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                          func (LikeFunction) EvaluateFunction

                                                                                                                                                                                                                                                                                                                                                                                          func (sf LikeFunction) EvaluateFunction(pa []float64) float64

                                                                                                                                                                                                                                                                                                                                                                                          func (LikeFunction) EvaluateGradient

                                                                                                                                                                                                                                                                                                                                                                                          func (sf LikeFunction) EvaluateGradient(point []float64) (gradient []float64)

                                                                                                                                                                                                                                                                                                                                                                                          type LikeResult

                                                                                                                                                                                                                                                                                                                                                                                          type LikeResult struct {
                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                            LikeResult likelihood value and site

                                                                                                                                                                                                                                                                                                                                                                                            type LikeSupResult

                                                                                                                                                                                                                                                                                                                                                                                            type LikeSupResult struct {
                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                            type MSeq

                                                                                                                                                                                                                                                                                                                                                                                            type MSeq struct {
                                                                                                                                                                                                                                                                                                                                                                                            	NM  string
                                                                                                                                                                                                                                                                                                                                                                                            	SQ  string
                                                                                                                                                                                                                                                                                                                                                                                            	SQs []string //SQ seperated by spaces
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              MSeq minimal seq struct

                                                                                                                                                                                                                                                                                                                                                                                              func ReadMSeqsFromFile

                                                                                                                                                                                                                                                                                                                                                                                              func ReadMSeqsFromFile(filen string) (seqs []MSeq, numstates int)

                                                                                                                                                                                                                                                                                                                                                                                                ReadMSeqsFromFile obvious file should be fasta in format with starts seperated by spaces and starting at 0 going to whatever

                                                                                                                                                                                                                                                                                                                                                                                                type MultStateModel

                                                                                                                                                                                                                                                                                                                                                                                                type MultStateModel struct {
                                                                                                                                                                                                                                                                                                                                                                                                	M DiscreteModel
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  MultStateModel multistate model struct

                                                                                                                                                                                                                                                                                                                                                                                                  func NewMultStateModel

                                                                                                                                                                                                                                                                                                                                                                                                  func NewMultStateModel(numstates int) *MultStateModel

                                                                                                                                                                                                                                                                                                                                                                                                    NewMultStateModel get new MULTModel pointer

                                                                                                                                                                                                                                                                                                                                                                                                    type Node

                                                                                                                                                                                                                                                                                                                                                                                                    type Node struct {
                                                                                                                                                                                                                                                                                                                                                                                                    	Par       *Node   //parent
                                                                                                                                                                                                                                                                                                                                                                                                    	Chs       []*Node //childs
                                                                                                                                                                                                                                                                                                                                                                                                    	Nam       string  //name
                                                                                                                                                                                                                                                                                                                                                                                                    	SData     map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                    	FData     map[string]float64
                                                                                                                                                                                                                                                                                                                                                                                                    	IData     map[string]int
                                                                                                                                                                                                                                                                                                                                                                                                    	Num       int
                                                                                                                                                                                                                                                                                                                                                                                                    	Len       float64     //branch length
                                                                                                                                                                                                                                                                                                                                                                                                    	Data      [][]float64 // [site][states]
                                                                                                                                                                                                                                                                                                                                                                                                    	BData     [][]*SupFlo //[site][states]
                                                                                                                                                                                                                                                                                                                                                                                                    	ContData  []float64   //[site] cont
                                                                                                                                                                                                                                                                                                                                                                                                    	Mis       []bool      //[site] missing site
                                                                                                                                                                                                                                                                                                                                                                                                    	Marked    bool        //just for like calculations
                                                                                                                                                                                                                                                                                                                                                                                                    	Height    float64
                                                                                                                                                                                                                                                                                                                                                                                                    	MarkedMap map[float64]bool //the float is for an id for the query
                                                                                                                                                                                                                                                                                                                                                                                                    	//anc+bl
                                                                                                                                                                                                                                                                                                                                                                                                    	// X------>--X
                                                                                                                                                                                                                                                                                                                                                                                                    	// TP        RT
                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                    	// X--<------X
                                                                                                                                                                                                                                                                                                                                                                                                    	// RvTp      RV
                                                                                                                                                                                                                                                                                                                                                                                                    	TpConds   [][]float64 //[site][states]
                                                                                                                                                                                                                                                                                                                                                                                                    	RtConds   [][]float64
                                                                                                                                                                                                                                                                                                                                                                                                    	RvConds   [][]float64
                                                                                                                                                                                                                                                                                                                                                                                                    	RvTpConds [][]float64
                                                                                                                                                                                                                                                                                                                                                                                                    	//TODO: need comments for these below
                                                                                                                                                                                                                                                                                                                                                                                                    	//FAD         float64
                                                                                                                                                                                                                                                                                                                                                                                                    	//LAD         float64
                                                                                                                                                                                                                                                                                                                                                                                                    	//FINDS       float64
                                                                                                                                                                                                                                                                                                                                                                                                    	//TimeLen     float64
                                                                                                                                                                                                                                                                                                                                                                                                    	PruneLen    float64
                                                                                                                                                                                                                                                                                                                                                                                                    	ConPruneLen []float64 // prevent race condition when calculating BM likelihood
                                                                                                                                                                                                                                                                                                                                                                                                    	BMLen       float64
                                                                                                                                                                                                                                                                                                                                                                                                    	Anc         bool
                                                                                                                                                                                                                                                                                                                                                                                                    	ClustLen    map[int]float64
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      Node minimal node struct

                                                                                                                                                                                                                                                                                                                                                                                                      func GetMrca

                                                                                                                                                                                                                                                                                                                                                                                                      func GetMrca(nds []*Node, root *Node) (mrca *Node)

                                                                                                                                                                                                                                                                                                                                                                                                        GetMrca get the mrca

                                                                                                                                                                                                                                                                                                                                                                                                        func GetSubtreeRoot

                                                                                                                                                                                                                                                                                                                                                                                                        func GetSubtreeRoot(n *Node, higherNode *Node) (subtreeRoot *Node)

                                                                                                                                                                                                                                                                                                                                                                                                          GetSubtreeRoot will return the root of the subtree to which a node belongs that descends from a higher node (up to the root)

                                                                                                                                                                                                                                                                                                                                                                                                          func ReadNewickString

                                                                                                                                                                                                                                                                                                                                                                                                          func ReadNewickString(ts string) (root *Node)

                                                                                                                                                                                                                                                                                                                                                                                                            ReadNewickString given a string it will return a pointer to the root node

                                                                                                                                                                                                                                                                                                                                                                                                            func (Node) BMPhylogram

                                                                                                                                                                                                                                                                                                                                                                                                            func (n Node) BMPhylogram() (ret string)

                                                                                                                                                                                                                                                                                                                                                                                                              BMPhylogram returns a string newick with brownian motion branch lengths

                                                                                                                                                                                                                                                                                                                                                                                                              func (*Node) GetBackbone

                                                                                                                                                                                                                                                                                                                                                                                                              func (n *Node) GetBackbone(higherNode *Node) (backbone []*Node)

                                                                                                                                                                                                                                                                                                                                                                                                                GetBackbone TODO: what is this

                                                                                                                                                                                                                                                                                                                                                                                                                func (*Node) GetSib

                                                                                                                                                                                                                                                                                                                                                                                                                func (n *Node) GetSib() *Node

                                                                                                                                                                                                                                                                                                                                                                                                                  GetSib returns the sibling of a node

                                                                                                                                                                                                                                                                                                                                                                                                                  func (Node) GetTipNames

                                                                                                                                                                                                                                                                                                                                                                                                                  func (n Node) GetTipNames() (tips []string)

                                                                                                                                                                                                                                                                                                                                                                                                                    GetTipNames returns a slice with node pointers

                                                                                                                                                                                                                                                                                                                                                                                                                    func (Node) GetTips

                                                                                                                                                                                                                                                                                                                                                                                                                    func (n Node) GetTips() (tips []*Node)

                                                                                                                                                                                                                                                                                                                                                                                                                      GetTips returns a slice with node pointers

                                                                                                                                                                                                                                                                                                                                                                                                                      func (Node) Newick

                                                                                                                                                                                                                                                                                                                                                                                                                      func (n Node) Newick(bl bool) (ret string)

                                                                                                                                                                                                                                                                                                                                                                                                                        Newick returns a string newick

                                                                                                                                                                                                                                                                                                                                                                                                                        func (Node) NewickFData

                                                                                                                                                                                                                                                                                                                                                                                                                        func (n Node) NewickFData(bl bool, FD string) (ret string)

                                                                                                                                                                                                                                                                                                                                                                                                                          NewickFData returns a string newick

                                                                                                                                                                                                                                                                                                                                                                                                                          func (Node) NewickFloatBL

                                                                                                                                                                                                                                                                                                                                                                                                                          func (n Node) NewickFloatBL(fl string) (ret string)

                                                                                                                                                                                                                                                                                                                                                                                                                            NewickFloatBL returns a string newick with branch lengths of the data in FData[fl]

                                                                                                                                                                                                                                                                                                                                                                                                                            func (Node) NewickPaint

                                                                                                                                                                                                                                                                                                                                                                                                                            func (n Node) NewickPaint(bl bool, rid float64) (ret string)

                                                                                                                                                                                                                                                                                                                                                                                                                              NewickPaint returns a string newick

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Node) NumIntNodes

                                                                                                                                                                                                                                                                                                                                                                                                                              func (n *Node) NumIntNodes(count *int)

                                                                                                                                                                                                                                                                                                                                                                                                                                NumIntNodes is a helper method that will return the number of internal nodes descending from n (including n)

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Node) PostorderArray

                                                                                                                                                                                                                                                                                                                                                                                                                                func (n *Node) PostorderArray() (ret []*Node)

                                                                                                                                                                                                                                                                                                                                                                                                                                  PostorderArray will return a postordered array of all the nodes starting at n

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Node) PostorderArrayExcl

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (n *Node) PostorderArrayExcl(x *Node) (ret []*Node)

                                                                                                                                                                                                                                                                                                                                                                                                                                    PostorderArrayExcl will return a postordered array of all the nodes starting at n

                                                                                                                                                                                                                                                                                                                                                                                                                                    excluding node x
                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Node) PreorderArray

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (n *Node) PreorderArray() (ret []*Node)

                                                                                                                                                                                                                                                                                                                                                                                                                                      PreorderArray will return a preordered array of all the nodes in a tree

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Node) Reroot

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (n *Node) Reroot(oldroot *Node) *Node

                                                                                                                                                                                                                                                                                                                                                                                                                                        Reroot reroots all the nodes represented in a graph on n

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Node) RerootBM

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (n *Node) RerootBM(oldroot *Node) *Node

                                                                                                                                                                                                                                                                                                                                                                                                                                          RerootBM reroots and moves the BMLen

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (Node) String

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (n Node) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                          type NodeStack

                                                                                                                                                                                                                                                                                                                                                                                                                                          type NodeStack struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                            NodeStack makes a node stack for pushing and pulling.

                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewNodeStack

                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewNodeStack() *NodeStack

                                                                                                                                                                                                                                                                                                                                                                                                                                              NewNodeStack returns a pointer to a node stack

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*NodeStack) Empty

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *NodeStack) Empty() (ret bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                Empty is the node stack empty?

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*NodeStack) Pop

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *NodeStack) Pop() (*Node, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pop a node off the stack

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*NodeStack) Push

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *NodeStack) Push(v *Node)

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Push push the node into the stack

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PLObj

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PLObj struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Rates                []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Durations            []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Dates                []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Mins                 []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PenMins              []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PenMaxs              []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Maxs                 []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CharDurations        []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	LogFactCharDurations []float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ParentsNdsInts       []int
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ChildrenVec          [][]int
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FreeNodes            []int
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FreeNodesM           map[int]bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NodesMap             map[int]*Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NumNodes             int
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	LogPen               bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PenaltyBoundary      float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Smoothing            float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	RateGroups           map[int]int //[nodenum]rategroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NumRateGroups        int
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CVNode               int
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Tree                 Tree
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Logs                 map[float64]float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                      PLObj things for PL

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*PLObj) CalcLF

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *PLObj) CalcLF(params []float64, free bool) float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                        CalcLF ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*PLObj) CalcMultLF

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *PLObj) CalcMultLF(params []float64, free bool) float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                          CalcMultLF ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*PLObj) CalcMultPL

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *PLObj) CalcMultPL(params []float64, free bool) float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                            CalcMultPL ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*PLObj) CalcPL

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (p *PLObj) CalcPL(params []float64, free bool) float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                              CalcPL ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*PLObj) CalcPLJustLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *PLObj) CalcPLJustLike(params []float64, free bool) float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*PLObj) CalcPenalty

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *PLObj) CalcPenalty() (rkt float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                CalcPenalty ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*PLObj) CalcRateLogLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (p *PLObj) CalcRateLogLike() (ll float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CalcRateLogLike ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*PLObj) CalcRateLogLikeP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (p *PLObj) CalcRateLogLikeP() (ll float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CalcRateLogLikeP ... NOT FASTER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*PLObj) CalcRoughnessPenalty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (p *PLObj) CalcRoughnessPenalty() (su float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CalcRoughnessPenalty ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*PLObj) CalcRoughnessPenaltyMult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *PLObj) CalcRoughnessPenaltyMult() (su float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CalcRoughnessPenaltyMult ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*PLObj) OptimizeRD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *PLObj) OptimizeRD(params []float64, likeFunc func([]float64, bool) float64,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LF bool, PL bool, MULT bool) *optimize.Result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          OptimizeRD optimization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*PLObj) OptimizeRDBOUNDED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *PLObj) OptimizeRDBOUNDED(params []float64, likeFunc func([]float64, bool) float64,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	LF bool, PL bool, alg int, verbose bool) ([]float64, float64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OptimizeRDBOUNDED NLOPT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*PLObj) OptimizeRDBOUNDEDIE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (p *PLObj) OptimizeRDBOUNDEDIE(params []float64, likeFunc func([]float64, bool) float64,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LF bool, PL bool, alg int, verbose bool, paramnodemap map[int]int) ([]float64, float64, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              OptimizeRDBOUNDEDIE NLOPT with inequality constraints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*PLObj) PCalcRateLogLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *PLObj) PCalcRateLogLike(jobs <-chan int, results chan<- float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*PLObj) PrintNewickDurations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *PLObj) PrintNewickDurations(t Tree) string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                PrintNewickDurations uses the NewickFloatBL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*PLObj) PrintNewickRates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (p *PLObj) PrintNewickRates(t Tree) string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*PLObj) RunCV

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (p *PLObj) RunCV(params []float64, verbose bool, likeFunc func([]float64, bool) float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RunCV ... this is just doing cross validation LOOCV

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*PLObj) RunLF

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (p *PLObj) RunLF(startRate float64, verbose bool) *optimize.Result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RunLF langley fitch run with starting float, probably numsites/20.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*PLObj) RunMLF

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (p *PLObj) RunMLF(startRate float64, mrcagroups []*Node, t Tree,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	verbose bool) *optimize.Result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RunMLF multiple rate langley fitch with starting float, probably x.X[0] from LF and mrcagroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*PLObj) RunMPL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *PLObj) RunMPL(mrcagroups []*Node, t Tree, verbose bool) *optimize.Result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RunMPL penalized likelihood run with a starting float from x.X[0] from LF and mrcagroup -- assuming that p.RateGroups has already been setup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*PLObj) RunPL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *PLObj) RunPL(startRate float64, verbose bool) *optimize.Result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          RunPL penalized likelihood run with a starting float, probably x.X[0] from LF

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*PLObj) SetDurations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *PLObj) SetDurations() (success bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetDurations for nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*PLObj) SetRateGroups

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (p *PLObj) SetRateGroups(tree Tree, mrcagroups []*Node)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetRateGroups send the mrcagroups that will identify the rate shifts these go preorder so have the deepest first if they are nested

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*PLObj) SetValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *PLObj) SetValues(t Tree, numsites float64, minmap map[*Node]float64,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	maxmap map[*Node]float64, verbose bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetValues ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ParsResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ParsResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ParsResult gives the parsimony score (value) for a site

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ProteinModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ProteinModel struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	M DiscreteModel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ProteinModel protein model struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewProteinModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewProteinModel() *ProteinModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewProteinModel get new PROTModel pointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ProteinModel) DeepCopyProteinModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (d *ProteinModel) DeepCopyProteinModel() *ProteinModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DeepCopyProteinModel ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ProteinModel) SetRateMatrixJTT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (d *ProteinModel) SetRateMatrixJTT()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetRateMatrixJTT set up JTT exchangeabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ProteinModel) SetRateMatrixLG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (d *ProteinModel) SetRateMatrixLG()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetRateMatrixLG set up LG exchangeabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ProteinModel) SetRateMatrixWAG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (d *ProteinModel) SetRateMatrixWAG()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetRateMatrixWAG set up WAG exchangeabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Quartet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Quartet struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Lt    map[int]bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Rt    map[int]bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Lts   []map[int]bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Rts   []map[int]bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Len   float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Index int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Quartet are represented as map[int]bools, one for the left and one for the right

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetQuartet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetQuartet(nd *Node, tree Tree, maptips map[string]int) (Quartet, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetQuartet for node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func GetQuartets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func GetQuartets(tree Tree, maptips map[string]int) (bps []Quartet)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetQuartets return slice of quartets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (Quartet) ConflictsWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (b Quartet) ConflictsWith(ib Quartet) (con bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ConflictsWith checks whether two biparts conflict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (Quartet) Match

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (b Quartet) Match(inq Quartet) (mat bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Match for matching quartets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (Quartet) StringWithNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (b Quartet) StringWithNames(nmmap map[int]string) (ret string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          StringWithNames converts the ints to the the strings from nmmap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Rfwresult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Rfwresult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tree1  int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tree2  int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Weight float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MaxDev float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Rfwresult struct for holding info from rfwp analysis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Seq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Seq struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NM string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	SQ string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Seq minimal seq struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ReadSeqsFromFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ReadSeqsFromFile(filen string) (seqs []Seq)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ReadSeqsFromFile obvious

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (Seq) GetFasta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s Seq) GetFasta() (ret string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetFasta return a fasta string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SortedIntIdxSlice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SortedIntIdxSlice struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	sort.IntSlice
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Idx []int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SortedIntIdxSlice for sorting indices of ints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSortedIdxSlice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSortedIdxSlice(n []int) *SortedIntIdxSlice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewSortedIdxSlice usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSortedIdxSliceD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSortedIdxSliceD(n ...int) *SortedIntIdxSlice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewSortedIdxSliceD usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s := NewSlice(1, 25, 3, 5, 4)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sort.Sort(s) will give s.IntSlice = [1 3 4 5 25] s.idx = [0 2 4 3 1]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (SortedIntIdxSlice) Swap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s SortedIntIdxSlice) Swap(i, j int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Swap for sorting indices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SupFlo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SupFlo super float

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func CalcSupLikeOneSite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func CalcSupLikeOneSite(t *Tree, x *DiscreteModel, site int) *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewSupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewSupFlo(m float64, e int) *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewSupFlo get a new one

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SupFlo) Abs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *SupFlo) Abs() *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Abs absolute value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SupFlo) Add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *SupFlo) Add(x *SupFlo) *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Add s+x return result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SupFlo) AddEq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *SupFlo) AddEq(x *SupFlo)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AddEq +=

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*SupFlo) Div

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *SupFlo) Div(x *SupFlo) *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Div s/x return sup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SupFlo) DivEq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *SupFlo) DivEq(x *SupFlo)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DivEq /=

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SupFlo) Float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *SupFlo) Float64() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Float64 just get it

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SupFlo) GetExp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *SupFlo) GetExp() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetExp just get it

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SupFlo) GetLn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *SupFlo) GetLn() *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetLn ln

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SupFlo) GetMant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *SupFlo) GetMant() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetMant just get it

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (SupFlo) Greater

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s SupFlo) Greater(x SupFlo) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Greater >

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (SupFlo) GreaterEq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s SupFlo) GreaterEq(x SupFlo) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GreaterEq >=

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (SupFlo) Less

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s SupFlo) Less(x SupFlo) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Less <

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (SupFlo) LessEq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s SupFlo) LessEq(x SupFlo) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        LessEq <=

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SupFlo) MinMin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *SupFlo) MinMin()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MinMin --

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SupFlo) Mul

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *SupFlo) Mul(x *SupFlo) *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Mul s * x return result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SupFlo) MulEq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *SupFlo) MulEq(x *SupFlo)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MulEq *=

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SupFlo) MulEqFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *SupFlo) MulEqFloat(x float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MulEqFloat *=

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SupFlo) MulFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *SupFlo) MulFloat(x float64) *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MulFloat s * x return result and x is a float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SupFlo) PlusPlus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *SupFlo) PlusPlus()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PlusPlus ++

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*SupFlo) SetFloat64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *SupFlo) SetFloat64(m float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetFloat64 set it to a float64 value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SupFlo) SetMantExp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *SupFlo) SetMantExp(mant float64, exp int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SupFlo) Sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *SupFlo) Sub(x *SupFlo) *SupFlo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sub s-x return result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SupFlo) SubEq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *SupFlo) SubEq(x SupFlo)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SubEq -=

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SupFlo) SwitchSign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *SupFlo) SwitchSign()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SwitchSign change the sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Tree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Tree struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Rt    *Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Post  []*Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Pre   []*Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Tips  []*Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Index int // if there is an identifying index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tree minimal phylogenetic tree struct don't need this, can use root but here if you want these convienence functions below

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewTree() *Tree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewTree return a tree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func ReadTreeFromFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func ReadTreeFromFile(tfn string) (tree *Tree)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ReadTreeFromFile read a single tree from a file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func ReadTreesFromFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func ReadTreesFromFile(tfn string) (trees []*Tree)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReadTreesFromFile read multi single tree from a file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Tree) GetTipByName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *Tree) GetTipByName(name string) (*Node, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetTipByName get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Tree) Instantiate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *Tree) Instantiate(rt *Node)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Instantiate will preorder and postorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bp is a tool for analyzing bipartitions from trees.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bp is a tool for analyzing bipartitions from trees.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        calcmsbl will calculate the branch lengths for multistate characters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        calcmsbl will calculate the branch lengths for multistate characters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parsbl is a tool to apply parsimony branch lengths to a tree.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parsbl is a tool to apply parsimony branch lengths to a tree.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        phytest is just for testing different functions in the phylogenetics stuff
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        phytest is just for testing different functions in the phylogenetics stuff