// WF returns the Wootton and Federhen complexity of a segment of s defined by // start and end. func WF(s seq.Sequence, start, end int) (cwf float64, err error) { if start < s.Start() || end > s.End() { err = fmt.Errorf("complex: index out of range") return } if start == end { return 0, nil } var N int k := s.Alphabet().Len() logk := math.Log(float64(k)) n := make([]int, k) // tally classes it := s.Alphabet().LetterIndex() for i := start; i < end; i++ { if ind := it[s.At(i).L]; ind >= 0 { N++ n[ind]++ } } // 1/N*log_k(N!/∏i=1..k(n_i!)) cwf = lnFac(N) for i := 0; i < k; i++ { cwf -= lnFac(n[i]) } cwf /= float64(N) * logk return }
// Entropic returns the entropic complexity of a segment of s defined by // start and end. func Entropic(s seq.Sequence, start, end int) (ce float64, err error) { if start < s.Start() || end > s.End() { err = fmt.Errorf("complex: index out of range") return } if start == end { return 0, nil } var N float64 k := s.Alphabet().Len() logk := math.Log(float64(k)) n := make([]float64, k) // tally classes it := s.Alphabet().LetterIndex() for i := start; i < end; i++ { if ind := it[s.At(i).L]; ind >= 0 { N++ n[ind]++ } } // -∑i=1..k((n_i/N)*log_k(n_i/N)) for i := 0; i < k; i++ { if n[i] != 0 { // ignore zero counts ce += n[i] * logBaseK(logk, n[i]/N) } } ce = -ce / N return }
// Z returns the zlib compression estimate of complexity of a segment of s defined by // start and end. func Z(s seq.Sequence, start, end int) (cz float64, err error) { if start < s.Start() || end > s.End() { err = fmt.Errorf("complex: index out of range") return } if start == end { return 0, nil } bc := new(byteCounter) z := zlib.NewWriter(bc) defer z.Close() it := s.Alphabet().LetterIndex() var N float64 for i := start; i < end; i++ { if b := byte(s.At(i).L); it[b] >= 0 { N++ z.Write([]byte{b}) } } z.Close() cz = (float64(*bc - overhead)) / N return }
// Write a single sequence and return the number of bytes written and any error. func (w *Writer) Write(s seq.Sequence) (n int, err error) { var ( _n int enc alphabet.Encoding ) if e, ok := s.(Encoder); ok { enc = e.Encoding() } else { enc = alphabet.Sanger } n, err = w.writeHeader('@', s) if err != nil { return } for i := 0; i < s.Len(); i++ { _n, err = w.w.Write([]byte{byte(s.At(i).L)}) if n += _n; err != nil { return } } _n, err = w.w.Write([]byte{'\n'}) if n += _n; err != nil { return } if w.QID { _n, err = w.writeHeader('+', s) if n += _n; err != nil { return } } else { _n, err = w.w.Write([]byte("+\n")) if n += _n; err != nil { return } } for i := 0; i < s.Len(); i++ { _n, err = w.w.Write([]byte{s.At(i).Q.Encode(enc)}) if n += _n; err != nil { return } } _n, err = w.w.Write([]byte{'\n'}) if n += _n; err != nil { return } return }
func (w *Writer) writeHeader(prefix byte, s seq.Sequence) (n int, err error) { var _n int n, err = w.w.Write([]byte{prefix}) if err != nil { return } _n, err = io.WriteString(w.w, s.Name()) if n += _n; err != nil { return } if desc := s.Description(); len(desc) != 0 { _n, err = w.w.Write([]byte{' '}) if n += _n; err != nil { return } _n, err = io.WriteString(w.w, desc) if n += _n; err != nil { return } } _n, err = w.w.Write([]byte("\n")) n += _n return }
// Write a single sequence and return the number of bytes written and any error. func (w *Writer) Write(s seq.Sequence) (n int, err error) { var ( _n int prefix = append([]byte{'\n'}, w.SeqPrefix...) ) id, desc := s.Name(), s.Description() header := make([]byte, 0, len(w.IDPrefix)+len(id)+len(desc)+1) header = append(header, w.IDPrefix...) header = append(header, id...) if len(desc) > 0 { header = append(header, ' ') header = append(header, desc...) } n, err = w.w.Write(header) if err != nil { return n, err } for i := 0; i < s.Len(); i++ { if i%w.Width == 0 { _n, err = w.w.Write(prefix) if n += _n; err != nil { return n, err } } _n, err = w.w.Write([]byte{byte(s.At(i).L)}) if n += _n; err != nil { return n, err } } _n, err = w.w.Write([]byte{'\n'}) if n += _n; err != nil { return n, err } return n, nil }