sequences

func AAPosition ¶

func AAPosition(dnaposition int) (aaposition int)

func AddFeature ¶

func AddFeature(annotated *wtype.DNASequence, newFeature wtype.Feature)

AddFeature adds a feature to a DNASequence The positions will be added automatically; if more than one matching sequence is found, multiple features will be added.

func AddFeatures ¶

func AddFeatures(dnaSeq *wtype.DNASequence, features []wtype.Feature)

AddFeatures adds features to the existing features of the DNASequence.

func CodonOptions ¶

func CodonOptions(codon string) (replacementoptions []string)

func DoublestrandedNonOverlappingORFS ¶

func DoublestrandedNonOverlappingORFS(seq string) (features features)

func DoublestrandedORFS ¶

func DoublestrandedORFS(seq string) (features features)

func EqualFold ¶

func EqualFold(a, b *wtype.DNASequence) bool

EqualFold compares whether two sequences are equivalent to each other.

The comparison will be performed in a case insensitive manner with respect to the actual sequence. The orientation is not important; i.e. a sequence and it's reverse complement will be classsified as equal. The two sequences must have the same circularisation status (i.e. both plasmid or both linear). If the sequences are plasmids then the rotation of the sequences is not important. Feature Annotations, double or single stranded status and overhang information are not taken into consideration.

func FindDirectionalPositionInSequence ¶

func FindDirectionalPositionInSequence(largeSequence wtype.DNASequence, smallSequence wtype.DNASequence) (start int, end int, err error)

FindDirectionalPositionInSequence returns the directional Positions of the feature. If more than one matching feature is found an error will be returned.

func FindPositionInSequence ¶

func FindPositionInSequence(largeSequence wtype.DNASequence, smallSequence wtype.DNASequence) (start int, end int, err error)

FindPositionInSequence returns directionless Positions; if a feature is found in the reverse orientation the first position found in the sequence will be returned rather than the start of the feature. If more than one matching feature is found an error will be returned.

func FindSeqsinSeqs ¶

func FindSeqsinSeqs(bigseq string, smallseqs []string) (seqsfound []search.Result)

FindSeqsinSeqs searches for small sequences (as strings) in a big sequence. The sequence is considered to be linear and matches will not be found if the sequence is circular and the sequence overlaps the end of the sequence. In this case, FindSeqs should be used.

func FindStarts ¶

func FindStarts(seq string) (atgs int)

type Promoter struct {
	StartPosition int
	EndPosition   int
	DNASeq        string
}

func FindPromoter (seq string) promoter Promoter {

seq = strings.ToUpper(seq)

if strings.Contains(seq,"TTGACA") {
	index := strings.Index(seq,"TTGACA")
	if strings.Index(seq+25,restofsequence := seq[index:]
	if
}

}

func GCcontent ¶

func GCcontent(fwdsequence string) (Percentage float64)

Calculate global GC content

func GtoMolarConc ¶

func GtoMolarConc(conc wunit.Concentration, mw float64) (molesperL float64)

calculate molar concentration of DNA sample

func Illegalnucleotides ¶

func Illegalnucleotides(fwdsequence wtype.DNASequence) (pass bool, illegalfound []search.Result, wobblefound []search.Result)

Check for illegal nucleotides

func InSequences ¶

func InSequences(seqs []*wtype.DNASequence, query *wtype.DNASequence) bool

InSequences evaluates whether a query is present in a set of DNASequences using the same criteria as the EqualFold function.

The comparison will be performed in a case insensitive manner with respect to the actual sequence. The orientation is not important; i.e. a sequence and it's reverse complement will be classsified as equal. The two sequences must have the same circularisation status (i.e. both plasmid or both linear). If the sequences are plasmids then the rotation of the sequences is not important. Feature Annotations, double or single stranded status and overhang information are not taken into consideration.

func LookforSpecificORF ¶

func LookforSpecificORF(seq string, targetAASeq string) (present bool)

func MakeAnnotatedSeq ¶

func MakeAnnotatedSeq(name string, seq string, circular bool, features []wtype.Feature) (annotated wtype.DNASequence, err error)

MakeAnnotatedSeq makes a DNA sequence adding the specified features with their correct positions in the sequence specified in human friendly format.

func MakeFeature ¶

func MakeFeature(name string, seq string, start int, end int, sequencetype string, class string, reverse string) (feature wtype.Feature)

MakeFeature constructs an annotated feature to be added to a sequence. The feature will be defined by it's class and it's position in the sequence once added to a sequence using AddFeature. A protein sequence can be specified if appropriate. valid class fields are:

ORF = "ORF"
CDS = "CDS"
GENE = "gene"
MISC_FEATURE = "misc_feature"
PROMOTER = "promoter"
TRNA = "tRNA"
RRNA = "rRNA"
NCRNA = "ncRNA"
REGULATORY = "regulatory"
REPEAT_REGION = "repeat_region"

valid sequence types entries are: "aa" = amino acid/ protein sequence "dna" = DNA sequence "rna = "RNA sequence Use the AddFeature function to add the feature to a DNASequence such that the positions are added correctly.

func MassDNA ¶

func MassDNA(fwdsequence string, phosphate5prime bool, doublestranded bool) (mw float64)

Calculate Molecular weight of DNA

func Molecularweight ¶

func Molecularweight(orf ORF) (kDa float64)

Molecularweight estimates molecular weight of a protein product.

func Moles ¶

func Moles(conc wunit.Concentration, mw float64, vol wunit.Volume) (moles float64)

func MolesDNA ¶

func MolesDNA(mass wunit.Mass, mw float64) (moles float64)

Calclulate number of moles of a mass of DNA

func MoletoGConc ¶

func MoletoGConc(molarconc float64, mw float64) (gperL wunit.Concentration)

func ORFs2Features ¶

func ORFs2Features(orfs []ORF) (features []wtype.Feature)

ORFs2Features converts a set of ORFs into a set of features

func Prefix ¶

func Prefix(seq string, lengthofprefix int) (prefix string)

func RemoveFeatures ¶

func RemoveFeatures(dnaSeq *wtype.DNASequence)

RemoveFeatures clears all existing feature annotations from a sequence.

func RemoveSite ¶

func RemoveSite(sequence wtype.DNASequence, enzyme wtype.RestrictionEnzyme, otherseqstoavoid []string) (newseq wtype.DNASequence, err error)

todo: fix this func

func RemoveSitesOutsideofFeatures ¶

func RemoveSitesOutsideofFeatures(dnaseq wtype.DNASequence, site string, algorithm ReplacementAlgorithm, featurelisttoavoid []wtype.Feature) (newseq wtype.DNASequence, err error)

func Replace ¶

func Replace(sequence wtype.DNASequence, position PositionPair, replaceWith wtype.DNASequence) (newSeq wtype.DNASequence, err error)

Replace takes a PositionPair and replaces the sequence between the pair with the replaeWith sequence. Features will be deleted if part of the feature is replaced. Note, if used to delete sections from a plasmid, the sequence returned will be in plasmid form and it will be attempted to maintion the original orientation. In this case it may be necessary to rotate the sequence if looking to generate a linear sequence of interest.

func ReplaceAll ¶

func ReplaceAll(sequence, seqToReplace, replaceWith wtype.DNASequence) (newSeq wtype.DNASequence, err error)

ReplaceAll searches for a sequence within a sequence and replaces all instances with the replaceWith sequence. Features will be deleted if part of the feature is replaced. Note, if used to delete sections from a plasmid, the sequence returned will be in plasmid form and it will be attempted to maintion the original orientation. In this case it may be necessary to rotate the sequence if looking to generate a linear sequence of interest.

func ReplaceAvoidingPositionPairs ¶

func ReplaceAvoidingPositionPairs(seq string, positionpairs []StartEndPair, original string, replacement string) (newseq string)

func ReplaceBycomplement ¶

func ReplaceBycomplement(sequence, thingtoreplace string, otherseqstoavoid []string) (replacement string, err error)

func ReplaceCodoninORF ¶

func ReplaceCodoninORF(sequence wtype.DNASequence, startandendoforf StartEndPair, position int, seqstoavoid []string) (newseq wtype.DNASequence, codontochange string, option string, err error)

func ReplacePosition ¶

func ReplacePosition(sequence string, position StartEndPair, replacement string) (newseq string)

func RevArrayOrder ¶

func RevArrayOrder(array []string) (reversedOrder []string)

func RevComp ¶

func RevComp(seq string) string

func RevTranslate ¶

func RevTranslate(aaSeq wtype.ProteinSequence, codonUsageTable CodonUsageTable) (dnaSeq wtype.DNASequence, err error)

RevTranslate converts an amino acid sequence into a dna sequence according the codon usage table specified. A CodonUsageTable is an interface for any type which has a ChooseCodon method. Examples of these are SimpleUsageTable, FrequencyTable and NTable

func RevTranslatetoNstring ¶

func RevTranslatetoNstring(aaSeq string) (NNN string)

RevTranslatetoNstring converts a string amino acid sequence to a sequence of NNN codons.

func Rotate ¶

func Rotate(seq wtype.DNASequence, rotateBy int, reverse bool) (rotatedSeq wtype.DNASequence)

Rotate will rotate the sequence by the number of characters specified by rotateBy. If reverse is true the sequence will be rotated in the reverse direction.

func SetFeatures ¶

func SetFeatures(dnaSeq *wtype.DNASequence, features []wtype.Feature)

SetFeatures replaces any existing feature annotations of the DNASequence with the features specified.

func Suffix ¶

func Suffix(seq string, lengthofsuffix int) (suffix string)

func Translate ¶

func Translate(dna wtype.DNASequence) (aa wtype.ProteinSequence, err error)

func ValidateSynthesis ¶

func ValidateSynthesis(parts []wtype.DNASequence, vector string, manufacturer string) (string, bool)

This simulates the sequence assembly reaction to validate if parts will synthesise with intended manufacturer. Does not validate construct assembly so should be used in conjunction with enzymes.Assemblysimulator()

func Wobble ¶

func Wobble(seq string) (alloptions []string)

Wobble returns an array of sequence options, as strings. Options are caclulated based on cross referencing each nucleotide with the WobbleMap to find each alternative option, if any, for that nucleotide. For example: ACT would return one sequence: ACT RCT would return ACT and GCT NCT would return ACT, GCT, TCT, CCT RYT would return ACT, GCT, ATT and GTT