// this time eviction is called by a scheduler for background, periodic evictions
func TimeEvict(lru *LRUCache, now time.Time, ttl time.Duration) {
lru.mu.Lock()
defer lru.mu.Unlock()
if lru.list.Len() < 1 {
return
}
var n *entry
var el *list.Element
hasEvictCallback := lru.EvictCallback != nil
el = lru.list.Back()
for {
if el == nil {
break
}
n = el.Value.(*entry)
if now.Sub(n.time_accessed) > ttl {
// the Difference is greater than max TTL so we need to evict this entry
// first grab the next entry (as this is about to dissappear)
el = el.Prev()
lru.remove(n.key)
if hasEvictCallback {
lru.EvictCallback(n.key, n.value)
}
} else {
// since they are stored in time order, as soon as we find
// first item newer than ttl window, we are safe to bail
break
}
}
lru.last_ttl_check = time.Now()
}
func (s *Summary) incrElement(el *list.Element) {
counter := el.Value.(*Counter)
counter.count++
// This element already has the largest count so it won't get moved.
if s.list.Front() == el {
return
}
// Starting at the previous element, move this element behind the first
// element we find which has a higher count.
moved := false
for currEl := el.Prev(); currEl != nil; currEl = currEl.Prev() {
if currEl.Value.(*Counter).count > counter.count {
s.list.MoveAfter(el, currEl)
moved = true
break
}
}
// If we didn't find an element with a higher count then this element must
// have the highest count. Move it to the front.
if !moved {
s.list.MoveToFront(el)
}
}
func (me *orderedList) ValueChanged(e *list.Element) {
for prev := e.Prev(); prev != nil && me.lessFunc(e.Value, prev.Value); prev = e.Prev() {
me.list.MoveBefore(e, prev)
}
for next := e.Next(); next != nil && me.lessFunc(next.Value, e.Value); next = e.Next() {
me.list.MoveAfter(e, next)
}
}
func (o *ObjectIndex) findForAddY(item Coordsable) *list.Element {
y := item.GetCoords().Y
var e *list.Element
for e = o.listY.Front(); e != nil; e = e.Next() {
if e.Value.(Coordsable).GetCoords().Y > y {
return e.Prev()
}
if e.Next() == nil {
return e
}
}
return nil
}
//---------------------------------------------------------------------
// parse data
//---------------------------------------------------------------------
func ikcp_parse_data(kcp *Ikcpcb, newseg *IKCPSEG) {
var p *list.Element
sn := newseg.sn
repeat := 0
if _itimediff(sn, kcp.rcv_nxt+kcp.rcv_wnd) >= 0 ||
_itimediff(sn, kcp.rcv_nxt) < 0 {
return
}
for p = kcp.rcv_buf.Back(); p != nil; p = p.Prev() {
seg := p.Value.(*IKCPSEG)
if seg.sn == sn {
repeat = 1
break
}
if _itimediff(sn, seg.sn) > 0 {
break
}
}
if repeat == 0 {
if p == nil {
kcp.rcv_buf.PushFront(newseg)
} else {
kcp.rcv_buf.InsertAfter(newseg, p)
}
kcp.nrcv_buf++
} else {
}
for p = kcp.rcv_buf.Front(); p != nil; {
seg := p.Value.(*IKCPSEG)
if seg.sn == kcp.rcv_nxt && kcp.nrcv_que < kcp.rcv_wnd {
q := p.Next()
kcp.rcv_buf.Remove(p)
p = q
kcp.nrcv_buf--
kcp.rcv_queue.PushBack(seg)
//if kcp.user[0] == 0 {
//fmt.Println("insert from recvqueue2", kcp.rcv_queue.Len(), kcp.user)
//}
kcp.nrcv_que++
kcp.rcv_nxt++
} else {
break
}
}
//println("inputok!!!", kcp.nrcv_buf, kcp.nrcv_que, repeat, kcp.rcv_nxt, sn)
}
func (o *ObjectIndex) ResortElement(element *list.Element) {
coords := element.Value.(Coordsable).GetCoords()
for e := element.Prev(); e != nil; e = element.Prev() {
if e.Value.(Coordsable).GetCoords().X < coords.X {
break
}
o.listX.MoveBefore(element, e)
}
for e := element.Next(); e != nil; e = element.Next() {
if e.Value.(Coordsable).GetCoords().X > coords.X {
break
}
o.listX.MoveAfter(element, e)
}
}
func (p *Program) elemLabelStmt(elem *list.Element) *LabelStatement {
if elem == nil {
return nil
}
stmt, ok := elem.Value.(*LabelStatement)
if ok {
return stmt
}
prev := elem.Prev()
if prev != nil {
stmt, ok = prev.Value.(*LabelStatement)
if ok {
return stmt
}
}
return nil
}
func (this *Tokenizer) Tokenize(p string, offset int, v *list.List) {
var t [10]string
var i *list.Element
var match bool
substr := 0
ln := 0
v = v.Init()
cont := 0
for cont < len(p) {
for WhiteSpace(p[cont]) {
cont++
offset++
}
LOG.Trace("Tokenizing [" + p[cont:] + "]")
match = false
for i = this.rules.Front(); i != nil && !match; i = i.Next() {
LOG.Trace("Checking rule " + i.Value.(Pair).first.(string))
ps := strings.Index(p[cont:], " ")
delta := cont + ps
if ps == -1 {
delta = cont + len(p) - cont
}
results := RegExHasSuffix(i.Value.(Pair).second.(*regexp.Regexp), p[cont:delta])
if len(results) > 0 {
match = true
ln = 0
substr = this.matches[i.Value.(Pair).first.(string)]
for j := If(substr == 0, 0, 1).(int); j <= substr && match; j++ {
t[j] = results[j]
ln += len(t[j])
LOG.Trace("Found match " + strconv.Itoa(j) + " [" + t[j] + "] for rule " + i.Value.(Pair).first.(string))
if string(i.Value.(Pair).first.(string)[0]) == "*" {
lower := strings.ToLower(t[j])
if !this.abrevs.Has(lower) {
match = false
LOG.Trace("Special rule and found match not in abbrev list. Rule not satisfied")
}
}
}
}
}
if match {
if i == nil {
i = this.rules.Back()
} else {
i = i.Prev()
}
substr = this.matches[i.Value.(Pair).first.(string)]
for j := If(substr == 0, 0, 1).(int); j <= substr && match; j++ {
if len(t[j]) > 0 {
LOG.Trace("Accepting matched substring [" + t[j] + "]")
w := NewWordFromLemma(t[j])
w.setSpan(offset, offset+len(t[j]))
offset += len(t[j])
v.PushBack(w)
} else {
LOG.Trace("Skipping matched null substring [" + t[j] + "]")
}
}
cont += ln
} else if cont < len(p) {
LOG.Warn("No rule matched input substring" + p[cont:] + " . Character " + string(p[cont:][0]) + " skipped . Check your tokenization rules")
cont++
}
}
offset++
}
func (this *HMMTagger) annotate(se *Sentence) {
var lemm *list.List
var emms *list.Element
var emmsant *list.Element
var w *list.Element
var ka *list.Element
var max float64 = 0
var aux float64 = 0
var emm float64 = 0
var pi float64 = 0
//kd := make(map[string]float64)
//ks := make(map[string]string)
var tag string
var t int
tr := NewTrellis(se.Len()+1, this.kbest)
lemm = this.FindStates(se)
w = se.Front()
emms = lemm.Front()
for i, _ := range emms.Value.(*set.Set).List() {
tk := emms.Value.(*set.Set).List()[i]
k := tk.(*Bigram)
pi = this.ProbPi_log(k)
emm = this.ProbB_log(k, w.Value.(*Word))
aux = pi + emm
tr.insert(0, k, tr.InitState, 0, aux)
}
t = 1
emmsant = lemm.Front()
emms = lemm.Front().Next()
for w = se.Front().Next(); w != nil; w = w.Next() {
for _, k := range emms.Value.(*set.Set).List() {
emm = this.ProbB_log(k.(*Bigram), w.Value.(*Word))
for _, kant := range emmsant.Value.(*set.Set).List() {
if kant.(*Bigram).Second == k.(*Bigram).First {
for kb := 0; kb < tr.nbest(t-1, kant.(*Bigram)); kb++ {
pant := tr.delta(t-1, kant.(*Bigram), kb)
ptrans := this.ProbA_log(kant.(*Bigram), k.(*Bigram), w)
aux = pant + ptrans + emm
tr.insert(t, k.(*Bigram), kant.(*Bigram), kb, aux)
}
}
}
}
t++
emmsant = emms
emms = emms.Next()
}
max = TRELLIS_ZERO_logprob
w = se.Back()
emms = lemm.Back()
for _, k := range emms.Value.(*set.Set).List() {
for kb := 0; kb < tr.nbest(se.Len()-1, k.(*Bigram)); kb++ {
aux = tr.delta(se.Len()-1, k.(*Bigram), kb)
tr.insert(se.Len(), tr.EndState, k.(*Bigram), kb, aux)
}
}
for w := se.Front(); w != nil; w = w.Next() {
w.Value.(*Word).unselectAllAnalysis(0)
}
for bp := 0; bp < tr.nbest(se.Len(), tr.EndState); bp++ {
back := tr.phi(se.Len(), tr.EndState, bp)
st := back.first.(*Bigram)
kb := back.second.(int)
tag = st.Second
w = se.Back()
for t := se.Len() - 1; t >= 0; t-- {
bestk := list.New()
max = 0.0
for ka = w.Value.(*Word).Front(); ka != nil; ka = ka.Next() {
if this.Tags.GetShortTag(ka.Value.(*Analysis).getTag()) == tag {
if ka.Value.(*Analysis).getProb() > max {
max = ka.Value.(*Analysis).getProb()
bestk = bestk.Init()
bestk.PushBack(ka.Value.(*Analysis))
} else if ka.Value.(*Analysis).getProb() == max {
bestk.PushBack(ka.Value.(*Analysis))
}
}
}
for k := bestk.Front(); k != nil; k = k.Next() {
w.Value.(*Word).selectAnalysis(k.Value.(*Analysis), bp)
}
if t > 0 {
back = tr.phi(t, st, kb)
st = back.first.(*Bigram)
kb = back.second.(int)
tag = st.Second
w = w.Prev()
}
}
}
TRACE(3, "sentence analyzed", MOD_HMM)
}
