align

type AlignChannel struct {
	Achan chan Alignment
	Err   error
}

type Alignment interface {
	SeqBag
	AddGaps(rate, lenprop float64)
	AddAmbiguities(rate, lenprop float64)
	Append(Alignment) error // Appends alignment sequences to this alignment
	AvgAllelesPerSite() float64
	BuildBootstrap(frac float64) Alignment // Bootstrap alignment
	CharStatsSite(site int) (map[uint8]int, error)
	Clone() (Alignment, error)
	CodonAlign(ntseqs SeqBag) (codonAl *align, err error)
	// Remove identical patterns/sites and return number of occurence
	// of each pattern (order of patterns/sites may have changed)
	Compress() []int
	// concatenates the given alignment with this alignment
	Concat(Alignment) error
	// Computes the majority consensus of the given alignemnt
	// To do so, it takes the majority character at each alignment site
	// if ignoreGaps is true, then gaps are not taken into account for majority computation (except if only Gaps)
	// if ignoreNs is true, then Ns are not taken into account for majority computation (except if only Ns)
	Consensus(ignoreGaps, ignoreNs bool) *align
	// Compares all sequences to the first one and counts all differences per sequence
	//
	// - alldiffs: The set of all differences that have been seen at least once
	// - diffs   : The number of occurences of each difference, for each sequence
	//             Sequences are ordered as the original alignment. Differences are
	//             written as REFNEW, ex: diffs["AC"]=12 .
	CountDifferences() (alldiffs []string, diffs []map[string]int)
	// Compares all sequences to the first one and replace identical characters with .
	DiffWithFirst()
	Entropy(site int, removegaps bool) (float64, error) // Entropy of the given site
	// Positions of potential frameshifts
	// if startinggapsasincomplete is true, then considers gaps as the beginning
	// as incomplete sequence, then take the right phase
	Frameshifts(startingGapsAsIncomplete bool) []struct{ Start, End int }
	// Returns informative positions of the alignment. Informative positions
	// are sites that contain at least two characters that occur at least twice each
	// X, N and GAPS are not considered in this definition
	InformativeSites() (sites []int)
	// Positions of potential stop in frame
	// if startinggapsasincomplete is true, then considers gaps as the beginning
	// as incomplete sequence, then take the right phase
	Stops(startingGapsAsIncomplete bool, geneticode int) (stops []int, err error)
	Length() int // Length of the alignment
	// maskreplace defines the replacing character. If maskreplace is "", then, masked characters
	// are replaced by "N" or "X" depending on the alphabet. Orherwise:
	//    1) if maskreplace is AMBIG: just like ""
	//    2) if maskreplace is MAJ: Replacing character is most frequent character of the column
	//    3) if maskreplace is GAP: Replacing character is a GAP
	// if nogap is true, then Mask will not replace gaps with the replacement character
	// if noref is true, then does not replace the character if it is the same as the reference sequences (only if refseq is specified).
	Mask(refseq string, start, length int, maskreplace string, nogap, noref bool) error // Masks given positions
	// Masks unique mutations in the given aligment (not the gaps).
	// If refseq is not "" then masks unique characters if
	//    1) they are different from the given reference sequence
	//    2) or if the reference is a GAP
	// maskreplace defines the replacing character. If maskreplace is "", then, masked characters
	// are replaced by "N" or "X" depending on the alphabet. Orherwise:
	//    1) if maskreplace is AMBIG: just like ""
	//    2)  if maskreplace is MAJ: Replacing character is most frequent character of the column
	//    3)  if maskreplace is GAP: Replacing character is a GAP
	MaskUnique(refseq string, maskreplace string) error
	// Masks mutations that appear less or equal than the given number of max occurences in their columns (not the gaps).
	// If refseq is not "" then masks these characters if
	//    1) they are different from the given reference sequence
	//    2) or if the reference is a GAP
	// maskreplace defines the replacing character. If maskreplace is "", then, masked characters
	// are replaced by "N" or "X" depending on the alphabet. Orherwise:
	//    1) if maskreplace is AMBIG: just like ""
	//    2)  if maskreplace is MAJ: Replacing character is most frequent character of the column
	//    3)  if maskreplace is GAP: Replacing character is a GAP
	MaskOccurences(refseq string, maxOccurence int, maskreplace string) error
	MaxCharStats(excludeGaps, excludeNs bool) (out []uint8, occur []int, total []int)
	Mutate(rate float64)  // Adds uniform substitutions in the alignment (~sequencing errors)
	NbVariableSites() int // Nb of variable sites
	// Number of Gaps in each sequence that are unique in their alignment site
	NumGapsUniquePerSequence(countProfile *CountProfile) (numuniques []int, numnew []int, numboth []int, err error)
	// returns the number of characters in each sequence that are unique in their alignment site (gaps or others)
	// It does not take into account 'N' and '-' as unique mutations
	NumMutationsUniquePerSequence(profile *CountProfile) (numuniques []int, numnew []int, nummuts []int, err error)
	Pssm(log bool, pseudocount float64, normalization int) (pssm map[uint8][]float64, err error) // Normalization: PSSM_NORM_NONE, PSSM_NORM_UNIF, PSSM_NORM_DATA
	Rarefy(nb int, counts map[string]int) (Alignment, error)                                     // Take a new rarefied sample taking into accounts weights
	RandSubAlign(length int, consecutive bool) (Alignment, error)                                // Extract a random subalignment with given length from this alignment
	Recombine(rate float64, lenprop float64, swap bool) error
	// converts coordinates on the given sequence to coordinates on the alignment
	RefCoordinates(name string, refstart, refend int) (alistart, aliend int, err error)
	// converts sites on the given sequence to coordinates on the alignment
	RefSites(name string, sites []int) (refsites []int, err error)
	// Overwrites the character at position "site" of the sequence "seqname" by "newchar"
	ReplaceChar(seqname string, site int, newchar uint8) error
	// Removes sites having >= cutoff gaps, returns the number of consecutive removed sites at start and end of alignment
	RemoveGapSites(cutoff float64, ends bool) (first, last int, kept, removed []int)
	// Removes sites having >= cutoff character, returns the number of consecutive removed sites at start and end of alignment
	RemoveCharacterSites(c []uint8, cutoff float64, ends bool, ignoreCase, ignoreGaps, ignoreNs, reverse bool) (first, last int, kept, removed []int)
	// Removes sites having >= cutoff of the main character at these sites, returns the number of consecutive removed sites at start and end of alignment
	RemoveMajorityCharacterSites(cutoff float64, ends, ignoreGaps, ignoreNs bool) (first, last int, kept, removed []int)
	// Replaces match characters (.) by their corresponding characters on the first sequence
	ReplaceMatchChars()
	Sample(nb int) (Alignment, error) // generate a sub sample of the sequences
	ShuffleSites(rate float64, roguerate float64, randroguefirst bool) []string
	SimulateRogue(prop float64, proplen float64) ([]string, []string) // add "rogue" sequences
	SiteConservation(position int) (int, error)                       // If the site is conserved:
	Split(part *PartitionSet) ([]Alignment, error)                    //Splits the alignment given the paritions in argument
	SubAlign(start, length int) (Alignment, error)                    // Extract a subalignment from this alignment
	SelectSites(sites []int) (Alignment, error)                       // Extract givens sites from the alignment
	InverseCoordinates(start, length int) (invstarts, invlengths []int, err error)
	InversePositions(sites []int) (invsites []int, err error)

	// Swap will exchange sequences from one seq to another of the alignment
	// if rate>=0 and rate<=1 then it takes rate/2 sequences and exhanges sequences
	// with rate/2 other sequences, from a random position
	// if pos >=0 and <=1, then take this position (relative to align length) instead of a random one
	Swap(rate, pos float64) error
	// TranslateByReference translates the alignment codon by codon using the given reference sequence as guide
	// We traverse reference nt 3 by 3
	// The reference codon may have gaps between nt ,
	// ex 1:
	// Ref: AC--GTACGT
	// Seq: ACTTGTACGT
	// In that case, the first ref codon is [0,1,4], corresponding to sequence ACTTG in seq
	// ACTTG % 3 != 0 ==> Frameshift? => Replaced by X in the compared sequence.
	// ex 2:
	// Ref: AC---GTACGT
	// Seq: ACTTTGTACGT
	// ref codon: [0,1,5]
	// seq      : ACTTTG : Insertion - OK => Replaced by "T-" in ref and "TT" in seq
	// ex 3:
	// Ref: ACGTACGT
	// Seq: A--TACGT
	// ref codon: [0,1,2]
	// seq      : A--: Deletion: not ok : Frameshift? => Replaced by "T" in ref and "X" in comp
	// ex 4:
	// Ref: AC----GTACGT
	// Seq: ACTT-TGTACGT
	// ref codon: [0,1,6]
	// seq      : ACTTTG : Insertion - OK => Replaced by "T-" in ref and "TT" in seq
	// ex 5:
	// Ref: AC----GTACGT
	// Seq: ACT--TGTACGT
	// ref codon: [0,1,6]
	// seq      : ACTTTG : Insertion not OK : Frameshift? => Replaced by "T-" in ref and "XX" in seq
	TranslateByReference(phase int, geneticcode int, refseq string) (err error)
	Transpose() (Alignment, error) // Output sequences are made of sites and output sites are sequences
	TrimSequences(trimsize int, fromStart bool) error
}

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

type Mutation struct {
	Ref []uint8
	Pos int
	Alt []uint8
}

type PairwiseAligner interface {
	AlignEnds() (int, int)
	AlignStarts() (int, int)
	Seq1Ali() []uint8
	Seq2Ali() []uint8
	SetGapOpenScore(open float64)
	SetGapExtendScore(extend float64)
	SetScore(match, mismatch float64)
	MaxScore() float64 // Maximum score of the alignment
	NbMatches() int    // Number of matches
	NbMisMatches() int // Number of mismatches
	NbGaps() int       // Nuber of gaps
	Length() int       // Length of the alignment
	Alignment() (Alignment, error)
	AlignmentStr() string
}

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

type PhasedSequence struct {
	Err      error
	Removed  bool
	Position int
	// phased nt sequence
	NtSeq Sequence
	// phased nt sequence
	// with first nt corresponding
	// first position of aa codon
	CodonSeq Sequence
	// phased aa sequence
	AaSeq Sequence
	// Aligned sequences
	// 1st: best found orf
	// 2nd: sequence
	Ali Alignment
}

type Phaser interface {
	Phase(orfs, seqs SeqBag) (chan PhasedSequence, error)
	SetLenCutoff(cutoff float64)
	SetMatchCutoff(cutoff float64)
	SetReverse(reverse bool)
	SetCutEnd(cutend bool)
	SetCpus(cpus int)
	SetTranslate(translate bool, geneticcode int) (err error)
	SetAlignScores(match, mismatch float64)
	SetGapOpen(float64)
	SetGapExtend(float64)
}

type SeqBag interface {
	AddSequence(name string, sequence string, comment string) error
	AddSequenceChar(name string, sequence []uint8, comment string) error
	AppendSeqIdentifier(identifier string, right bool)
	Alphabet() int
	SetAlphabet(int) error // Sets the alphabet
	AlphabetStr() string
	AlphabetCharacters() []uint8
	AlphabetCharToIndex(c uint8) int // Returns index of the character (nt or aa) in the AlphabetCharacters() array
	AutoAlphabet()                   // detects and sets alphabet automatically for all the sequences
	DetectAlphabet() (alphabet int)  //  detects the compatible alphabets
	CharStats() map[uint8]int64
	UniqueCharacters() []uint8
	CharStatsSeq(idx int) (map[uint8]int, error)               // Computes frequency of characters for the given sequence
	CleanNames(namemap map[string]string)                      // Clean sequence names (newick special char)
	Clear()                                                    // Removes all sequences
	CloneSeqBag() (seqs SeqBag, err error)                     // Clones the seqqbag
	Deduplicate(nAsGap bool) (identical [][]string, err error) // Remove duplicate sequences (nAsGap is for considering N/X identical to gaps for sequence comparison)
	FilterLength(minlength, maxlength int) error               // Remove sequences whose length is <minlength or >maxlength
	GetSequence(name string) (string, bool)                    // Get a sequence by names
	GetSequenceById(ith int) (string, bool)
	GetSequenceChar(name string) ([]uint8, bool)
	GetSequenceCharById(ith int) ([]uint8, bool)
	GetSequenceNameById(ith int) (string, bool)
	GetSequenceByName(name string) (Sequence, bool)
	GetSequenceIdByName(name string) (i int) // if the name does not exist, i < 0
	SetSequenceChar(ithAlign, ithSite int, char uint8) error
	// IgnoreIdentical sets the behavior when duplicate names are encountered while building the alignment
	// If ignore is IGNORE_NONE: Does not ignore anything
	// If ignore is IGNORE_NAME: Ignore sequences having the same name (keep the first one whatever their sequence)
	// If ignore is IGNORE_SEQUENCE: Ignore sequences having the same name and the same sequence
	// Otherwise, sets IGNORE_NONE
	IgnoreIdentical(int)
	SampleSeqBag(nb int) (SeqBag, error) // generate a sub sample of the sequences
	Sequence(ith int) (Sequence, bool)
	SequenceByName(name string) (Sequence, bool)
	Identical(SeqBag) bool
	Iterate(it func(name string, sequence string) bool)
	IterateChar(it func(name string, sequence []uint8) bool)
	IterateAll(it func(name string, sequence []uint8, comment string) bool)
	Sequences() []Sequence
	SequencesChan() chan Sequence
	LongestORF(reverse bool) (orf Sequence, err error)
	MaxNameLength() int // maximum sequence name length
	NbSequences() int
	RarefySeqBag(nb int, counts map[string]int) (SeqBag, error) // Take a new rarefied sample taking into accounts weights
	// Removes sequences having >= cutoff gaps, returns number of removed sequences
	RemoveGapSeqs(cutoff float64, ignoreNs bool) int
	// Removes sequences having >= cutoff character, returns number of removed sequences
	RemoveCharacterSeqs(c uint8, cutoff float64, ignoreCase, ignoreGaps, ignoreNs bool) int
	Rename(namemap map[string]string)
	RenameRegexp(regex, replace string, namemap map[string]string) error
	Replace(old, new string, regex bool) error             // Replaces old string with new string in sequences of the alignment
	ReplaceStops(phase int, geneticode int) error          // Replaces stop codons in the given phase using the given genetic code
	ShuffleSequences()                                     // Shuffle sequence order
	String() string                                        // Raw string representation (just write all sequences)
	Translate(phase int, geneticcode int) (err error)      // Translates nt sequence in aa
	ToUpper()                                              // replaces lower case characters by upper case characters
	ToLower()                                              // replaces upper case characters by lower case characters
	ReverseComplement() (err error)                        // Reverse-complements the alignment
	ReverseComplementSequences(name ...string) (err error) // Reverse-complements some sequences in the alignment
	TrimNames(namemap map[string]string, size int) error
	TrimNamesAuto(namemap map[string]string, curid *int) error
	Sort() // Sorts the sequences by name
	Unalign() SeqBag
}

type Sequence interface {
	Sequence() string
	SequenceChar() []uint8
	SameSequence([]uint8) bool
	CharAt(int) uint8
	Name() string
	SetName(name string)
	Comment() string
	Length() int
	LongestORF() (start, end int) // Detects the longest ORF in forward strand only
	Reverse()
	Complement() error                                      // Returns an error if not nucleotide sequence
	Translate(phase int, geneticcode int) (Sequence, error) // Translates the sequence using the given code
	DetectAlphabet() int                                    // Try to detect alphabet (nt or aa)
	NumGaps() int                                           // Number of Gaps
	NumGapsOpenning() int                                   // Number of Gaps opennin, it counts streches of gap only once
	NumGapsFromStart() int                                  // Number of Gaps from Start (until a non gap is encountered)
	NumGapsFromEnd() int                                    // Number of Gaps from End (until a non gap is encountered)
	// returns the number of differences between the reference sequence and each sequence of the alignment
	// If lengths are different, returns an error
	// It does not take into account 'N' and '-' in sequences as mutations compared to ref
	/// sequence (ref sequence can have a '-' or a 'N')
	NumMutationsComparedToReferenceSequence(alphabet int, seq Sequence) (nummutations int, err error)
	// returns the list of differences between the reference sequence and each sequence of the alignment
	// Counts only non N sites in each sequences (may be a gap or a N in the reference sequence though)
	// If a character is ambigous (IUPAC notation), then it is counted as a mutation only if it is incompatible with
	// the reference character.
	// if codon is true: the sequences are nucleotides and nucleotides are taken codon by codon of the reference sequence
	// to list mutations.
	// it translate is true (codon must be true also):  Translate each codon. In case of insertion or a deletion in the target sequence: if %3==0: - or aa insert,
	// otherwise "/" ~frameshift?
	//
	// If lengths are different, returns an error
	ListMutationsComparedToReferenceSequence(alphabet int, refseq Sequence, codon bool, translate bool) (mutations []Mutation, err error)

	Clone() Sequence
}