Exemplo n.º 1
0
func ListEntries(w http.ResponseWriter,
	r *http.Request) (gbEntries []GbEntryRetr, report string) {

	c := appengine.NewContext(r)
	/* High Replication Datastore:
	Ancestor queries are strongly consistent.
	Queries spanning MULTIPLE entity groups are EVENTUALLY consistent.
	If .Ancestor was omitted from this query, there would be slight chance
	that recent GB entry would not show up in a query.
	*/
	q := ds.NewQuery(GbEntryKind).Ancestor(keyParent(c)).Order("-Date").Limit(10)
	gbEntries = make([]GbEntryRetr, 0, 10)
	keys, err := q.GetAll(c, &gbEntries)

	if fmt.Sprintf("%T", err) == fmt.Sprintf("%T", new(ds.ErrFieldMismatch)) {
		//s := fmt.Sprintf("%v %T  vs %v %T <br>\n",err,err,ds.ErrFieldMismatch{},ds.ErrFieldMismatch{})
		loghttp.E(w, r, err, true)
		err = nil // ignore this one - it's caused by our deliberate differences between gbsaveEntry and gbEntrieRetr
	}
	loghttp.E(w, r, err, false)

	// for investigative purposes,
	// we
	var b1 bytes.Buffer
	var sw string
	var descrip []string = []string{"class", "path", "key_int_guestbk"}
	for i0, v0 := range keys {
		sKey := fmt.Sprintf("%v", v0)
		v1 := strings.Split(sKey, ",")
		sw = fmt.Sprintf("key %v", i0)
		b1.WriteString(sw)
		for i2, v2 := range v1 {
			d := descrip[i2]
			sw = fmt.Sprintf(" \t %v:  %q ", d, v2)
			b1.WriteString(sw)
		}
		b1.WriteString("\n")
	}
	report = b1.String()

	for _, gbe := range gbEntries {
		s := gbe.Comment1
		if len(s) > 0 {
			if pos := strings.Index(s, "0300"); pos > 1 {
				i1 := util.Max(pos-4, 0)
				i2 := util.Min(pos+24, len(s))
				s1 := s[i1:i2]
				s1 = strings.Replace(s1, "3", "E", -1)
				report = fmt.Sprintf("%v -%v", report, s1)
			}
		}
	}

	return
}
Exemplo n.º 2
0
// FillHeightFloor is the recommended minimal height
// of an amorph to fill in.
//
func (f Fusion) FillHeightFloor() int {

	if f.xyx == nil || len(f.xyx) < 2 {
		return cFusionHeightDefault
	}

	if f.xyx[1] > 0 {
		// lower western flank => max of western or middle flank
		if f.w == nil || len(f.w) < 1 {
			return cFusionHeightDefault
		}
		return util.Max(f.xyx[1], f.w[0])
	} else {
		// lower eastern flank => max of eastern or middle flank
		if f.e == nil || len(f.e) < 1 {
			return cFusionHeightDefault
		}
		return util.Max(-f.xyx[1], f.e[0])
	}

}
Exemplo n.º 3
0
// mostAbundant seeks the largest slice.
// It then returns the first amorph.
func mostAbundant(amorphBlocks [][]Amorph) (chosen *Amorph) {

	maxFound := 0
	for i := 0; i < len(amorphBlocks); i++ {
		maxFound = util.Max(maxFound, len(amorphBlocks[i]))
	}

	for i := 0; i < len(amorphBlocks); i++ {
		if len(amorphBlocks[i]) == maxFound {
			if len(amorphBlocks[i]) > 0 {
				return &amorphBlocks[i][0]
			}
		}
	}
	return nil
}
Exemplo n.º 4
0
// mostAbundant seeks the largest slice.
// It then returns the first amorph.
// Should be replaced by abundantHeightMatch()
func (dummy MostAbundant) Filter(amorphBlocks [][]Amorph, fs Fusion) (chosen *Amorph) {

	maxFound := 0
	for i := 0; i < len(amorphBlocks); i++ {
		maxFound = util.Max(maxFound, len(amorphBlocks[i]))
	}

	for i := 0; i < len(amorphBlocks); i++ {
		if len(amorphBlocks[i]) == maxFound {
			if len(amorphBlocks[i]) > 0 {
				return &amorphBlocks[i][0]
			}
		}
	}
	return nil
}
Exemplo n.º 5
0
func backend3(w http.ResponseWriter, r *http.Request, m map[string]interface{}) {

	c := appengine.NewContext(r)

	var nColsBlock = 4
	if r.FormValue("nColsBlock") != "" {
		nColsBlock = util.Stoi(r.FormValue("nColsBlock"))
	}
	var nColsViewport = 6
	if r.FormValue("nColsViewport") != "" {
		nColsViewport = util.Stoi(r.FormValue("nColsViewport"))
	}

	myB0.VB1 = X
	myB0.NumB1 = len(myB0.VB1)
	myB0.NumB2 = 0
	myB0.NColsViewport = nColsViewport

	// compute basic meta data
	for i1, _ := range myB0.VB1 {
		myB0.NumB2 += len(myB0.VB1[i1].VB2)
		for i2, _ := range myB0.VB1[i1].VB2 {
			// number of chars
			ro := myB0.VB1[i1].VB2[i2] // read only
			myB0.VB1[i1].VB2[i2].Size = len(ro.Linktext) + len(ro.Description)
			myB0.VB1[i1].VB2[i2].EditorialIndex = i2
		}
	}

	// compute NCols - NRows for the block
	for i1, _ := range myB0.VB1 {
		myB0.VB1[i1].NCols = nColsBlock
		if myB0.VB1[i1].NColsEditorial > 0 {
			myB0.VB1[i1].NCols = myB0.VB1[i1].NColsEditorial
		}
		if len(myB0.VB1[i1].VB2) < nColsBlock && len(myB0.VB1[i1].VB2) > 0 {
			myB0.VB1[i1].NCols = len(myB0.VB1[i1].VB2)
		}
		myB0.VB1[i1].NRows = complementRowsOrCols(len(myB0.VB1[i1].VB2), myB0.VB1[i1].NCols)
		myB0.VB1[i1].Discrepancy = myB0.VB1[i1].NCols*myB0.VB1[i1].NRows - len(myB0.VB1[i1].VB2)

		myB0.MaxNCols = util.Max(myB0.MaxNCols, myB0.VB1[i1].NCols)
		myB0.MaxNRows = util.Max(myB0.MaxNRows, myB0.VB1[i1].NRows)
	}

	// compute NCols - NRows - sizeup to MaxNRows
	for i1, _ := range myB0.VB1 {
		if myB0.VB1[i1].NRows < myB0.MaxNRows {
			myB0.VB1[i1].NRows = myB0.MaxNRows
			myB0.VB1[i1].NCols = complementRowsOrCols(len(myB0.VB1[i1].VB2), myB0.VB1[i1].NRows)
			myB0.VB1[i1].Discrepancy = myB0.VB1[i1].NCols*myB0.VB1[i1].NRows - len(myB0.VB1[i1].VB2)
		}
	}

	// is first or last
	for i1, _ := range myB0.VB1 {
		for i2, _ := range myB0.VB1[i1].VB2 {
			myB0.VB1[i1].VB2[i2].IsFirst = false
			myB0.VB1[i1].VB2[i2].IsLast = false
			if i2%myB0.VB1[i1].NCols == 0 {
				myB0.VB1[i1].VB2[i2].IsFirst = true
			}
			if i2%myB0.VB1[i1].NCols == (myB0.VB1[i1].NCols - 1) {
				myB0.VB1[i1].VB2[i2].IsLast = true
			}
			//aelog.Infof(c,"first-last %v %v \n", i2, i2%myB0.VB1[i1].NCols)
		}
	}

	// create slices with the data to be sorted
	for i1, _ := range myB0.VB1 {
		sh1 := make([]Order, len(myB0.VB1[i1].VB2))
		myB0.VB1[i1].BySize = ByInt(sh1)
		sh2 := make([]Order, len(myB0.VB1[i1].VB2))
		myB0.VB1[i1].ByHeading = ByStr(sh2)
		// fill in the data - to be sorted later
		for i2, _ := range myB0.VB1[i1].VB2 {
			ro := myB0.VB1[i1].VB2[i2] // read only
			myB0.VB1[i1].BySize[i2].IdxSrc = i2
			myB0.VB1[i1].BySize[i2].ByI = len(ro.Linktext) + len(ro.Description)
			myB0.VB1[i1].ByHeading[i2].IdxSrc = i2
			myB0.VB1[i1].ByHeading[i2].ByS = strings.ToLower(ro.Linktext)
		}
	}

	// actual rearranging of the sorting date
	for i1, _ := range myB0.VB1 {
		sort.Sort(myB0.VB1[i1].BySize)
		sort.Sort(myB0.VB1[i1].ByHeading)
		aelog.Infof(c, "-- Sorting %v", myB0.VB1[i1].Heading)
		// for i, v := range myB0.VB1[i1].BySize {
		// 	aelog.Infof(c,"---- %v %v %v", i, v.IdxSrc, v.ByI)
		// }
		// for i, v := range myB0.VB1[i1].ByHeading {
		// 	aelog.Infof(c,"---- %v %v %v", i, v.IdxSrc, v.ByS)
		// }
	}

	path := m["dir"].(string) + m["base"].(string)

	cntr, _ := sc.Count(c, path)

	add, tplExec := tplx.FuncTplBuilder(w, r)
	add("n_html_title", "Backend", nil)

	add("n_cont_0", "<style>"+htmlfrag.CSSColumnsWidth(nColsViewport)+"</style>", "")
	add("n_cont_1", tplx.PrefixLff+"backend3_body", myB0)
	add("tpl_legend", tplx.PrefixLff+"backend3_body_embed01", "")
	add("n_cont_2", "<p>{{.}} views</p>", cntr)

	sDumped := ""
	//sDumped = spew.Sdump(myB0)
	add("n_cont_3", "<pre>{{.}} </pre>", sDumped)

	tplExec(w, r)

}
Exemplo n.º 6
0
// enhanceLine extends the first segment horizontally westwards.
// It then adds a fictional vertical.
// Finally we add a horizontal margin.
// Eastwards we draw a pit down to vprFloor and then go vertically upwards.
// Param stillEmpty draws a bottom between the two vertical axis.
//
//
// ---┐                 ┌---
//    |                 |
//    |                 |
//    └---------┐       |
//          XXXX|       |
//          XXXX|       |
//              |       |
//              └-------┘
//
func (m *TransposableMatrix) enhanceLine(stillEmpty bool, line []Point,
	xm1, xm2 int) []Point {

	if !m.enforceVPR {
		return line
	}

	// mapping
	vprmx1, vprmy1 := m.transposeBase2Mapped(m.vPRx1, m.vPRy1)
	vprmx2, vprmy2 := m.transposeBase2Mapped(m.vPRx2, m.vPRy2)

	var vpr1, vpr2, vprFloor int // effective limits, depending on perspective
	if m.persp%2 == 1 {
		vpr1, vpr2 = vprmx1, vprmx2
		vprFloor = util.Max(vprmy1, vprmy2)
	} else {
		vpr1, vpr2 = vprmy1, vprmy2
		vprFloor = util.Max(vprmx1, vprmx2)
	}

	if stillEmpty {
		line = []Point{
			Point{vpr1, vprFloor},
			Point{vpr2, vprFloor},
		}
		pf("empty outline => artificial floor %v\n", line)
		xm1 = vpr1 + 1 // so that forthcoming comparisons apply
		xm2 = vpr2 - 1
	}

	// westward extension
	if vpr1 < xm1 {

		if vprFloor == line[0].y {
			line[0].x = vpr1 // simply prolong
		} else {
			// We could step up/down
			// but then we get gaps.
			// Thus we only step up/down eastwards
			line[0].x = vpr1
		}

		// fictitious vertical upward
		line = append([]Point{Point{}}, line...)
		line[0].x = line[1].x
		line[0].y = line[1].y - fictSegLen

		// fictitious westward horiz segment
		line = append([]Point{Point{}}, line...)
		line[0].x = line[1].x - fictSegLen
		line[0].y = line[1].y

	}

	// eastward extension
	if vpr2 > xm2 {

		if xm2 == vpr2-1 {

			// prolong eastwards one more slot
			lastIdx := len(line) - 1
			line[lastIdx].x = vpr2

		} else if vprFloor == line[0].y {

			// prolong eastwards along x-axis
			lastIdx := len(line) - 1
			line[lastIdx].x = vpr2

		} else {

			// make a full pit/bulge to vprFloor:

			// up/down ...
			lastIdx := len(line) - 1
			line = append(line, Point{})
			line[lastIdx+1].x = line[lastIdx].x
			line[lastIdx+1].y = vprFloor

			// ... and east
			lastIdx = len(line) - 1
			line = append(line, Point{})
			line[lastIdx+1].x = vpr2
			line[lastIdx+1].y = line[lastIdx].y

		}

		// fictitious vertical upward
		lastIdx := len(line) - 1
		line = append(line, Point{})
		line[lastIdx+1].x = line[lastIdx].x
		line[lastIdx+1].y = line[lastIdx].y - fictSegLen

		// fictitious eastw horiz
		lastIdx = len(line) - 1
		line = append(line, Point{})
		line[lastIdx+1].x = line[lastIdx].x + fictSegLen
		line[lastIdx+1].y = line[lastIdx].y
	}

	//
	//
	if vpr1 > xm1 {
		// todo: cropping existing outline
	}
	if xm2 > vpr2 {
		// todo: cropping existing outline
	}

	return line
}
Exemplo n.º 7
0
// FuseTwoSections takes an outline with all concavest lowest narrowest sections,
// and one or two designated section indize out of clns.
// So far mostly *one* section is given, while the second is the
// computed right neighbor. Rightmost sect is complemented by the left neighbor.
// Those designated sections are fused.
// Param l    => outline
// Param clns => concavest, lowest, narrowest sections
// sct1       => index to clns for which to find a pair
// Returns: Fusion
func (ar *Reservoir) FuseTwoSections(l []Point, clns [][]int, sct1 []int) (Fusion, error) {

	fs := NewFusion()
	var err error

	// find the two sections - westward or eastward
	west, east := findYourNeighbor(clns, sct1)
	var sct2 []int
	if sct1[1] == 0 {
		// only fuse eastw possible
		if east < 0 {
			err = epf("NO EASTW NEIGHBOR 1 to %v", sct1)
			return fs, err
		}
		sct2 = clns[east]
	} else if sct1[1] == len(l)-1 {
		// only fuse westw possible
		if west < 0 {
			err = epf("NO WESTW NEIGHBOR 1 to %v", sct1)
			return fs, err
		}
		sct2 = sct1
		sct1 = clns[west]
	} else {
		if util.Abs(sct1[3]) > 0 &&
			util.Abs(sct1[3]) < util.Abs(sct1[6]) {
			// east flank higher than west flank?
			// => fuse westwards
			sct2 = sct1
			if west < 0 {
				err = epf("NO WESTW NEIGHBOR 2 to %v", sct1)
				return fs, err
			}
			sct1 = clns[west]
		} else {
			// fuse eastwards
			if east < 0 {
				err = epf("NO EASTW NEIGHBOR 2 to %v", sct1)
				return fs, err
			}
			sct2 = clns[east]
		}
	}
	// PrintSectOfCLNS(sct1)
	// PrintSectOfCLNS(sct2)

	fs.idxL = append(fs.idxL, sct1[0], sct1[1], sct2[0], sct2[1])
	fs.xyx = append(fs.xyx, sct1[2], sct1[6], sct2[2])
	fs.w = append(fs.w, sct1[3], sct1[4], sct1[5])
	fs.e = append(fs.e, sct2[6], sct2[7], sct2[8])

	sdgN := ar.SmallestDesirableHeight
	sdgWE := ar.SmallestDesirableWidth

	pW, pE, pN := Permissiveness(sdgN, sdgWE, fs.xyx, fs.w, fs.e)
	fs.pm = []int{pW, pE, pN}

	//
	// base point
	// always bottom left
	fs.base.x = l[sct1[0]].x             // x-coord taken from beginning
	baseY1 := l[sct1[0]].y               // y-coord taken either from beginning
	baseY2 := l[sct2[1]].y               //      or taken from end
	fs.base.y = util.Max(baseY1, baseY2) // take lowest y - meaning Max(), not Min()
	dyw := sct1[3]                       // correction for concave angles
	if dyw > 0 {
		fs.base.x++
	}

	switch {
	case fs.pm[0] < 0 && fs.pm[1] < 0: // eastw, westw blocked, concave
		fs.curveDesc = cncave
		fs.dirIdx, fs.maxOffs = -1, 0
	case fs.pm[0] > 0 && fs.pm[1] < 0: //  westwards
		fs.curveDesc = stairW
		fs.dirIdx, fs.maxOffs = 0, fs.pm[0]
	case fs.pm[0] < 0 && fs.pm[1] > 0: //  eastwards
		fs.curveDesc = stairE
		fs.dirIdx, fs.maxOffs = 1, fs.pm[1]
	case fs.pm[0] > 0 && fs.pm[1] > 0: // utterly convex
		fs.curveDesc = convex
		fs.dirIdx, fs.maxOffs = 1, fs.pm[1] // wanton choice: grow east
	}

	lowerX := 0
	if fs.xyx[1] < 0 {
		lowerX = 1
	}
	if lowerX == 0 && fs.w[0] > 0 {
		fs.concaveCore = true
	}
	if lowerX == 1 && fs.e[0] > 0 {
		fs.concaveCore = true
	}

	return fs, nil
}
Exemplo n.º 8
0
func similarTextifiedTrees2(src *TextifiedTree, mp map[string][]*TextifiedTree, skipPrefix map[string]bool) {

	// srcE := word.WrapAsEqualer(string(src.Text), true) // ssrc as Equaler
	srcE := wordb.WrapAsEqualer(src.Text, true)
	srcLen := float64(len(src.Text))

	for fnKey, tts := range mp {

		if fnKey == src.SourceID {
			pf("    to %v SKIP self\n", fnKey)
			continue
		}

		pf("    to %v\n", fnKey)

		cntr, br := 0, true
		for _, tt := range tts {
			// outl, text := tt.Outl, tt.Text

			if tt.Lvl > src.Lvl+levelsTolerance {
				break // since we are now sorted by lvl, we can this is safe
			}

			if tt.Lvl == src.Lvl ||
				(tt.Lvl > src.Lvl && tt.Lvl <= src.Lvl+levelsTolerance) {
				// proceed
			} else {
				continue
			}

			if src.NumTokens < 1 {
				continue
			}

			if src.NumTokens < 5 && tt.NumTokens > 7 {
				continue
			}

			if HistoBasedDistance(src, tt) > 0.51 {
				breakMapsTooDistinct++
				continue
			}

			relSize := srcLen / float64(util.Max(1, len(tt.Text)))
			if relSize < 0.33 || relSize > 3 {
				continue
			}

			absDist, relDist := 0, 0.0

			if tt.NumTokens == src.NumTokens &&
				len(tt.Text) == len(src.Text) &&
				bytes.Equal(tt.Text, src.Text) {
				absDist, relDist = 0, 0.0
				appliedCompare++
			} else {
				dstE := wordb.WrapAsEqualer(tt.Text, true) // destinations as Equaler
				m := levenshtein.New(srcE, dstE, opt)
				absDist, relDist = m.Distance()
				appliedLevenshtein++
			}

			//
			if relDist < 0.26 && absDist < 10 {
				if br {
					pf("\t")
				}

				sd := ""
				sd = string(tt.Text[:util.Min(2*excerptLen, len(tt.Text)-1)])
				sd = stringspb.ToLen(sd, 2*excerptLen+1)
				pf("%12v %v %4v %5.2v   ", tt.Outline, sd, absDist, relDist)

				cntr++
				br = false

				sim := Similar{}
				sim.SourceID = fnKey
				sim.Lvl = tt.Lvl
				sim.Outline = tt.Outline
				sim.AbsLevenshtein = absDist
				sim.RelLevenshtein = relDist
				sim.Text = tt.Text
				src.Similars = append(src.Similars, sim)
				src.SumAbsLevenshtein += absDist
				src.SumRelLevenshtein += relDist

				if cntr%2 == 0 || cntr > 20 {
					pf("\n")
					br = true
				}
				if cntr > 20 {
					break
				}
			}

		}
		if !br {
			pf("\n")
		}
	}

}