Example #1
0
// Init initialises FORM structure
func (o *ReliabFORM) Init(μ, σ []float64, lrv []bool, gfcn ReliabGfcn_t, hfcn ReliabHfcn_t) {

	// input
	o.μ = μ
	o.σ = σ
	o.lrv = lrv
	o.gfcn = gfcn
	o.hfcn = hfcn

	// default constants
	o.NmaxItA = 10
	o.NmaxItB = 10
	o.TolA = 0.001
	o.TolB = 0.001
	o.NlsSilent = true
	o.NlsCheckJ = false
	o.NlsCheckJtol = 1e-9

	// allocate slices
	nx := len(μ)
	chk.IntAssert(len(σ), nx)
	chk.IntAssert(len(lrv), nx)
	o.α = make([]float64, nx)
	o.xtmp = make([]float64, nx)
	o.dgdx = make([]float64, nx)
}
Example #2
0
func Test_nurbs02(tst *testing.T) {

	//verbose()
	chk.PrintTitle("nurbs02")

	// NURBS
	b := FactoryNurbs2dPlateHole()
	elems := b.Elements()
	nbasis := b.GetElemNumBasis()
	io.Pforan("nbasis = %v\n", nbasis)
	chk.IntAssert(nbasis, 9) // orders := (2,2) => nbasis = (2+1)*(2+1) = 9

	// check basis and elements
	chk.Ints(tst, "elem[0]", elems[0], []int{2, 3, 2, 3})
	chk.Ints(tst, "elem[1]", elems[1], []int{3, 4, 2, 3})
	chk.Ints(tst, "ibasis0", b.IndBasis(elems[0]), []int{0, 1, 2, 4, 5, 6, 8, 9, 10})
	chk.Ints(tst, "ibasis1", b.IndBasis(elems[1]), []int{1, 2, 3, 5, 6, 7, 9, 10, 11})
	chk.IntAssert(b.GetElemNumBasis(), len(b.IndBasis(elems[0])))

	// check derivatives
	b.CheckDerivs(tst, 11, 1e-5, false)

	// refine NURBS
	c := b.KrefineN(2, false)
	elems = c.Elements()
	chk.IntAssert(c.GetElemNumBasis(), len(c.IndBasis(elems[0])))

	// check refined elements
	io.Pf("\n------------ refined -------------\n")
	chk.Ints(tst, "elem[0]", elems[0], []int{2, 3, 2, 3})
	chk.Ints(tst, "elem[1]", elems[1], []int{3, 4, 2, 3})
	chk.Ints(tst, "elem[2]", elems[2], []int{4, 5, 2, 3})
	chk.Ints(tst, "elem[3]", elems[3], []int{5, 6, 2, 3})
	chk.Ints(tst, "elem[4]", elems[4], []int{2, 3, 3, 4})
	chk.Ints(tst, "elem[5]", elems[5], []int{3, 4, 3, 4})
	chk.Ints(tst, "elem[6]", elems[6], []int{4, 5, 3, 4})
	chk.Ints(tst, "elem[7]", elems[7], []int{5, 6, 3, 4})

	// check refined basis
	chk.Ints(tst, "ibasis0", c.IndBasis(elems[0]), []int{0, 1, 2, 6, 7, 8, 12, 13, 14})
	chk.Ints(tst, "ibasis1", c.IndBasis(elems[1]), []int{1, 2, 3, 7, 8, 9, 13, 14, 15})
	chk.Ints(tst, "ibasis2", c.IndBasis(elems[2]), []int{2, 3, 4, 8, 9, 10, 14, 15, 16})
	chk.Ints(tst, "ibasis3", c.IndBasis(elems[3]), []int{3, 4, 5, 9, 10, 11, 15, 16, 17})
	chk.Ints(tst, "ibasis4", c.IndBasis(elems[4]), []int{6, 7, 8, 12, 13, 14, 18, 19, 20})
	chk.Ints(tst, "ibasis5", c.IndBasis(elems[5]), []int{7, 8, 9, 13, 14, 15, 19, 20, 21})
	chk.Ints(tst, "ibasis6", c.IndBasis(elems[6]), []int{8, 9, 10, 14, 15, 16, 20, 21, 22})
	chk.Ints(tst, "ibasis7", c.IndBasis(elems[7]), []int{9, 10, 11, 15, 16, 17, 21, 22, 23})

	// plot
	if chk.Verbose {
		io.Pf("\n------------ plot -------------\n")
		la := 0 + 0*b.n[0]
		lb := 2 + 1*b.n[0]
		PlotNurbs("/tmp/gosl/gm", "nurbs02a.png", b, 41, true, nil)
		PlotNurbsBasis("/tmp/gosl/gm", "nurbs02b.png", b, la, lb)
		PlotNurbsDerivs("/tmp/gosl/gm", "nurbs02c.png", b, la, lb)
		PlotTwoNurbs("/tmp/gosl/gm", "nurbs02d.png", b, c, 41, true, nil)
	}
}
Example #3
0
func Test_frees01a(tst *testing.T) {

	// finalise analysis process and catch errors
	defer End()

	//verbose()
	chk.PrintTitle("frees01a")

	// start simulation
	if !Start("data/frees01.sim", true, chk.Verbose) {
		chk.Panic("cannot start FE simulation")
	}

	// domain
	distr := false
	dom := NewDomain(Global.Sim.Regions[0], distr)
	if dom == nil {
		chk.Panic("cannot run FE simulation")
	}

	// set stage
	if !dom.SetStage(0, Global.Sim.Stages[0], distr) {
		chk.Panic("cannot set stage\n")
	}

	// nodes and elements
	chk.IntAssert(len(dom.Nodes), 62)
	chk.IntAssert(len(dom.Elems), 15)

	// vertices with "fl"
	seepverts := map[int]bool{3: true, 45: true, 7: true, 49: true, 11: true, 53: true, 15: true, 57: true, 19: true, 61: true, 23: true}

	// check dofs
	var seepeqs []int
	for _, nod := range dom.Nodes {
		if seepverts[nod.Vert.Id] {
			chk.IntAssert(len(nod.Dofs), 2)
			seepeqs = append(seepeqs, nod.Dofs[1].Eq)
		} else {
			chk.IntAssert(len(nod.Dofs), 1)
		}
	}
	sort.Ints(seepeqs)
	io.Pforan("seepeqs = %v\n", seepeqs)
	chk.Ints(tst, "seepeqs", seepeqs, []int{14, 16, 19, 30, 32, 43, 45, 56, 58, 69, 71})

	// check Fmap
	e2 := dom.Elems[2].(*ElemP)
	chk.Ints(tst, "e2.Fmap", e2.Fmap, []int{14, 16, 19})
	e5 := dom.Elems[5].(*ElemP)
	chk.Ints(tst, "e5.Fmap", e5.Fmap, []int{16, 30, 32})
	e8 := dom.Elems[8].(*ElemP)
	chk.Ints(tst, "e8.Fmap", e8.Fmap, []int{30, 43, 45})
	e11 := dom.Elems[11].(*ElemP)
	chk.Ints(tst, "e11.Fmap", e11.Fmap, []int{43, 56, 58})
	e14 := dom.Elems[14].(*ElemP)
	chk.Ints(tst, "e14.Fmap", e14.Fmap, []int{56, 69, 71})
}
Example #4
0
func Test_frees01a(tst *testing.T) {

	//verbose()
	chk.PrintTitle("frees01a")

	// start simulation
	analysis := NewFEM("data/frees01.sim", "", true, false, false, false, chk.Verbose, 0)

	// set stage
	err := analysis.SetStage(0)
	if err != nil {
		tst.Errorf("SetStage failed:\n%v", err)
		return
	}

	// initialise solution vectros
	err = analysis.ZeroStage(0, true)
	if err != nil {
		tst.Errorf("ZeroStage failed:\n%v", err)
		return
	}

	// domain
	dom := analysis.Domains[0]

	// nodes and elements
	chk.IntAssert(len(dom.Nodes), 62)
	chk.IntAssert(len(dom.Elems), 15)

	// vertices with "fl"
	seepverts := map[int]bool{3: true, 45: true, 7: true, 49: true, 11: true, 53: true, 15: true, 57: true, 19: true, 61: true, 23: true}

	// check dofs
	var seepeqs []int
	for _, nod := range dom.Nodes {
		if seepverts[nod.Vert.Id] {
			chk.IntAssert(len(nod.Dofs), 2)
			seepeqs = append(seepeqs, nod.Dofs[1].Eq)
		} else {
			chk.IntAssert(len(nod.Dofs), 1)
		}
	}
	sort.Ints(seepeqs)
	io.Pforan("seepeqs = %v\n", seepeqs)
	chk.Ints(tst, "seepeqs", seepeqs, []int{14, 16, 19, 30, 32, 43, 45, 56, 58, 69, 71})

	// check Fmap
	e2 := dom.Elems[2].(*ElemP)
	chk.Ints(tst, "e2.Fmap", e2.Fmap, []int{14, 16, 19})
	e5 := dom.Elems[5].(*ElemP)
	chk.Ints(tst, "e5.Fmap", e5.Fmap, []int{16, 30, 32})
	e8 := dom.Elems[8].(*ElemP)
	chk.Ints(tst, "e8.Fmap", e8.Fmap, []int{30, 43, 45})
	e11 := dom.Elems[11].(*ElemP)
	chk.Ints(tst, "e11.Fmap", e11.Fmap, []int{43, 56, 58})
	e14 := dom.Elems[14].(*ElemP)
	chk.Ints(tst, "e14.Fmap", e14.Fmap, []int{56, 69, 71})
}
Example #5
0
// PlotTwoVarsContour plots contour for two variables problem. len(x) == 2
//  Input
//   dirout  -- directory to save files
//   fnkey   -- file name key for eps figure
//   x       -- solution. can be <nil>
//   np      -- number of points for contour
//   extra   -- called just before saving figure
//   axequal -- axis.equal
//   vmin    -- min 0 values
//   vmax    -- max 1 values
//   f       -- function to plot filled contour. can be <nil>
//   gs      -- functions to plot contour @ level 0. can be <nil>
func PlotTwoVarsContour(dirout, fnkey string, x []float64, np int, extra func(), axequal bool,
	vmin, vmax []float64, f TwoVarsFunc_t, gs ...TwoVarsFunc_t) {
	if fnkey == "" {
		return
	}
	chk.IntAssert(len(vmin), 2)
	chk.IntAssert(len(vmax), 2)
	V0, V1 := utl.MeshGrid2D(vmin[0], vmax[0], vmin[1], vmax[1], np, np)
	var Zf [][]float64
	var Zg [][][]float64
	if f != nil {
		Zf = la.MatAlloc(np, np)
	}
	if len(gs) > 0 {
		Zg = utl.Deep3alloc(len(gs), np, np)
	}
	xtmp := make([]float64, 2)
	for i := 0; i < np; i++ {
		for j := 0; j < np; j++ {
			xtmp[0], xtmp[1] = V0[i][j], V1[i][j]
			if f != nil {
				Zf[i][j] = f(xtmp)
			}
			for k, g := range gs {
				Zg[k][i][j] = g(xtmp)
			}
		}
	}
	plt.Reset()
	plt.SetForEps(0.8, 350)
	if f != nil {
		cmapidx := 0
		plt.Contour(V0, V1, Zf, io.Sf("fsz=7, cmapidx=%d", cmapidx))
	}
	for k, _ := range gs {
		plt.ContourSimple(V0, V1, Zg[k], false, 8, "zorder=5, levels=[0], colors=['yellow'], linewidths=[2], clip_on=0")
	}
	if x != nil {
		plt.PlotOne(x[0], x[1], "'r*', label='optimum', zorder=10")
	}
	if extra != nil {
		extra()
	}
	if dirout == "" {
		dirout = "."
	}
	plt.Cross("clr='grey'")
	plt.SetXnticks(11)
	plt.SetYnticks(11)
	if axequal {
		plt.Equal()
	}
	plt.AxisRange(vmin[0], vmax[0], vmin[1], vmax[1])
	args := "leg_out='1', leg_ncol=4, leg_hlen=1.5"
	plt.Gll("$x_0$", "$x_1$", args)
	plt.SaveD(dirout, fnkey+".eps")
}
Example #6
0
// Set copies states
//  Note: 1) this and other states must have been pre-allocated with the same sizes
//        2) this method does not check for errors
func (o *OnedState) Set(other *OnedState) {
	o.Sig = other.Sig
	o.Dgam = other.Dgam
	o.Loading = other.Loading
	chk.IntAssert(len(o.Alp), len(other.Alp))
	chk.IntAssert(len(o.Phi), len(other.Phi))
	copy(o.Alp, other.Alp)
	copy(o.Phi, other.Phi)
	o.F = other.F
}
Example #7
0
func Test_mylab09(tst *testing.T) {

	//verbose()
	chk.PrintTitle("mylab09. arg min and max")

	u := []float64{1, 2, 3, -5, 60, -10, 8}
	imin, imax := DblArgMinMax(u)
	io.Pforan("imin = %v (5)\n", imin)
	io.Pforan("imax = %v (4)\n", imax)
	chk.IntAssert(imin, 5)
	chk.IntAssert(imax, 4)
}
Example #8
0
// SetIniIvs sets initial ivs for given values in sol and ivs map
func (o *ElemUP) SetIniIvs(sol *Solution, ivs map[string][]float64) (err error) {

	// set p-element first
	err = o.P.SetIniIvs(sol, nil)
	if err != nil {
		return
	}

	// initial stresses given
	if _, okk := ivs["svT"]; okk {

		// total vertical stresses and K0
		nip := len(o.U.IpsElem)
		svT := ivs["svT"]
		K0s := ivs["K0"]
		chk.IntAssert(len(svT), nip)
		chk.IntAssert(len(K0s), 1)
		K0 := K0s[0]

		// for each integration point
		sx := make([]float64, nip)
		sy := make([]float64, nip)
		sz := make([]float64, nip)
		for i, ip := range o.U.IpsElem {

			// compute pl @ ip
			err = o.P.Cell.Shp.CalcAtIp(o.P.X, ip, false)
			if err != nil {
				return
			}
			pl := 0.0
			for m := 0; m < o.P.Cell.Shp.Nverts; m++ {
				pl += o.P.Cell.Shp.S[m] * sol.Y[o.P.Pmap[m]]
			}

			// compute effective stresses
			p := pl * o.P.States[i].A_sl
			svE := svT[i] + p
			shE := K0 * svE
			sx[i], sy[i], sz[i] = shE, svE, shE
			if o.Ndim == 3 {
				sx[i], sy[i], sz[i] = shE, shE, svE
			}
		}
		ivs = map[string][]float64{"sx": sx, "sy": sy, "sz": sz}
	}

	// set u-element
	return o.U.SetIniIvs(sol, ivs)
}
Example #9
0
func Test_hist01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("hist01")

	lims := []float64{0, 1, 2, 3, 4, 5}
	hist := Histogram{Stations: lims}

	idx := hist.FindBin(-3.3)
	chk.IntAssert(idx, -1)

	idx = hist.FindBin(7.0)
	chk.IntAssert(idx, -1)

	for i, x := range lims {
		idx = hist.FindBin(x)
		io.Pforan("x=%g idx=%d\n", x, idx)
		if i < len(lims)-1 {
			chk.IntAssert(idx, i)
		} else {
			chk.IntAssert(idx, -1)
		}
	}

	idx = hist.FindBin(0.5)
	chk.IntAssert(idx, 0)

	idx = hist.FindBin(1.5)
	chk.IntAssert(idx, 1)

	idx = hist.FindBin(2.5)
	chk.IntAssert(idx, 2)

	idx = hist.FindBin(3.99999999999999)
	chk.IntAssert(idx, 3)

	idx = hist.FindBin(4.999999)
	chk.IntAssert(idx, 4)

	hist.Count([]float64{
		0, 0.1, 0.2, 0.3, 0.9, // 5
		1, 1, 1, 1.2, 1.3, 1.4, 1.5, 1.99, // 8
		2, 2.5, // 2
		3, 3.5, // 2
		4.1, 4.5, 4.9, // 3
		-3, -2, -1,
		5, 6, 7, 8,
	}, true)
	io.Pforan("counts = %v\n", hist.Counts)
	chk.Ints(tst, "counts", hist.Counts, []int{5, 8, 2, 2, 3})

	labels := hist.GenLabels("%g")
	io.Pforan("labels = %v\n", labels)
}
Example #10
0
func Test_nurbs03(tst *testing.T) {

	//verbose()
	chk.PrintTitle("nurbs03")

	// NURBS
	b := FactoryNurbs1dCurveA()
	elems := b.Elements()
	nbasis := b.GetElemNumBasis()
	io.Pforan("nbasis = %v\n", nbasis)
	chk.IntAssert(nbasis, 4) // orders := (3,) => nbasis = (3+1) = 4

	// check basis and elements
	chk.Ints(tst, "elem[0]", elems[0], []int{3, 4})
	chk.Ints(tst, "elem[1]", elems[1], []int{4, 5})
	chk.Ints(tst, "elem[2]", elems[2], []int{5, 6})
	chk.Ints(tst, "ibasis0", b.IndBasis(elems[0]), []int{0, 1, 2, 3})
	chk.Ints(tst, "ibasis1", b.IndBasis(elems[1]), []int{1, 2, 3, 4})
	chk.Ints(tst, "ibasis2", b.IndBasis(elems[2]), []int{2, 3, 4, 5})

	// refine NURBS
	c := b.Krefine([][]float64{
		{0.15, 0.5, 0.85},
	})

	// plot
	if chk.Verbose {
		PlotNurbs("/tmp/gosl/gm", "nurbs03a.png", b, 41, true, nil)
		PlotTwoNurbs("/tmp/gosl/gm", "nurbs03b.png", b, c, 41, true, nil)
	}
}
Example #11
0
// RouletteSelect selects n individuals
//  Input:
//    cumprob -- cumulated probabilities (from sorted population)
//    sample  -- a list of random numbers; can be nil
//  Output:
//    selinds -- selected individuals (indices). len(selinds) == nsel
func RouletteSelect(selinds []int, cumprob []float64, sample []float64) {
	nsel := len(selinds)
	chk.IntAssertLessThanOrEqualTo(nsel, len(cumprob))
	if sample == nil {
		var s float64
		for i := 0; i < nsel; i++ {
			s = rand.Float64()
			for j, m := range cumprob {
				if m > s {
					selinds[i] = j
					break
				}
			}
		}
		return
	}
	chk.IntAssert(len(sample), nsel)
	for i, s := range sample {
		for j, m := range cumprob {
			if m > s {
				selinds[i] = j
				break
			}
		}
	}
}
Example #12
0
func Test_mylab09(tst *testing.T) {

	//verbose()
	chk.PrintTitle("mylab09. arg min and max and L2norm")

	u := []float64{1, 2, 3, -5, 60, -10, 8}
	imin, imax := DblArgMinMax(u)
	io.Pforan("imin = %v (5)\n", imin)
	io.Pforan("imax = %v (4)\n", imax)
	chk.IntAssert(imin, 5)
	chk.IntAssert(imax, 4)

	v := []float64{0, 1, 8, 0, -1, 3, 4}
	d := L2norm(u, v)
	io.Pforan("d = %v\n", d)
	chk.Scalar(tst, "L2(u,v)", 1e-17, d, 62.912637840103322)
}
Example #13
0
func Test_nurbs01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("nurbs01")

	msh, err := ReadMsh("data", "nurbs01.msh", 0)
	if err != nil {
		tst.Errorf("test failed:\n%v", err)
		return
	}

	for _, cell := range msh.Cells {
		p0, p1 := cell.Shp.Nurbs.Ord(0), cell.Shp.Nurbs.Ord(1)
		io.Pfcyan("cell # %d : NURBS orders = (%d,%d)\n", cell.Id, p0, p1)
		chk.IntAssert(p0, 2)
		chk.IntAssert(p1, 2)
	}
}
Example #14
0
// CumSum returns the cumulative sum of the elements in p
//  Input:
//   p -- values
//  Output:
//   cs -- cumulated sum; pre-allocated with len(cs) == len(p)
func CumSum(cs, p []float64) {
	if len(p) < 1 {
		return
	}
	chk.IntAssert(len(cs), len(p))
	cs[0] = p[0]
	for i := 1; i < len(p); i++ {
		cs[i] = cs[i-1] + p[i]
	}
}
Example #15
0
// Point returns the x-y-z coordinates of a point on Bezier curve
func (o *BezierQuad) Point(C []float64, t float64) {
	if len(o.Q) != 3 {
		chk.Panic("Point: quadratic Bezier must be initialised first (with 3 control points)")
	}
	ndim := len(o.Q[0])
	chk.IntAssert(len(C), ndim)
	for i := 0; i < ndim; i++ {
		C[i] = (1.0-t)*(1.0-t)*o.Q[0][i] + 2.0*t*(1.0-t)*o.Q[1][i] + t*t*o.Q[2][i]
	}
	return
}
Example #16
0
// ConnectSet connects set of parameters
func (o *Prms) ConnectSet(V []*float64, names []string, caller string) (err string) {
	chk.IntAssert(len(V), len(names))
	for i, name := range names {
		prm := o.Find(name)
		if prm == nil {
			return io.Sf("cannot find parameter named %q as requested by %q\n", name, caller)
		}
		prm.Connect(V[i])
	}
	return
}
Example #17
0
func Test_hist02(tst *testing.T) {

	//verbose()
	chk.PrintTitle("hist02")

	lims := []int{0, 1, 2, 3, 4, 5}
	hist := IntHistogram{Stations: lims}

	idx := hist.FindBin(-3)
	chk.IntAssert(idx, -1)

	idx = hist.FindBin(7)
	chk.IntAssert(idx, -1)

	for i, x := range lims {
		idx = hist.FindBin(x)
		io.Pforan("x=%g idx=%d\n", x, idx)
		if i < len(lims)-1 {
			chk.IntAssert(idx, i)
		} else {
			chk.IntAssert(idx, -1)
		}
	}

	hist.Count([]int{
		0, 0, 0, 0, 0, // 5
		1, 1, 1, 1, 1, 1, 1, 1, // 8
		2, 2, // 2
		3, 3, // 2
		4, 4, 4, // 3
		-3, -2, -1,
		5, 6, 7, 8,
	}, true)
	io.Pforan("counts = %v\n", hist.Counts)
	chk.Ints(tst, "counts", hist.Counts, []int{5, 8, 2, 2, 3})

	labels := hist.GenLabels("%d")
	io.Pforan("labels = %v\n", labels)
}
Example #18
0
// DblsParetoMinProb compares two vectors using Pareto's optimal criterion
// φ ∃ [0,1] is a scaling factor that helps v win even if it's not smaller.
// If φ==0, deterministic analysis is carried out. If φ==1, probabilistic analysis is carried out.
// As φ → 1, v "gets more help".
//  Note: (1) minimum dominates (is better)
//        (2) v dominates if !u_dominates
func DblsParetoMinProb(u, v []float64, φ float64) (u_dominates bool) {
	chk.IntAssert(len(u), len(v))
	var pu, pv float64
	for i := 0; i < len(u); i++ {
		pu += ProbContestSmall(u[i], v[i], φ)
		pv += ProbContestSmall(v[i], u[i], φ)
	}
	pu /= float64(len(u))
	if FlipCoin(pu) {
		u_dominates = true
	}
	return
}
Example #19
0
func Test_cubiceq02(tst *testing.T) {

	//verbose()
	chk.PrintTitle("cubiceq02. y(x) = x³ + x²")

	a, b, c := 1.0, 0.0, 0.0
	x1, x2, x3, nx := EqCubicSolveReal(a, b, c)
	io.Pforan("\na=%v b=%v c=%v\n", a, b, c)
	io.Pfcyan("nx=%v\n", nx)
	io.Pfcyan("x1=%v x2=%v x3=%v\n", x1, x2, x3)
	chk.IntAssert(nx, 2)
	chk.Scalar(tst, "x1", 1e-17, x1, -1)
	chk.Scalar(tst, "x2", 1e-17, x2, 0)
}
Example #20
0
// SimpleOutput implements a simple output function
func SimpleOutput(first bool, dx, x float64, y []float64, args ...interface{}) (err error) {
	chk.IntAssert(len(args), 1)
	res := args[0].(*Results)
	res.Dx = append(res.Dx, dx)
	res.X = append(res.X, x)
	ndim := len(y)
	if len(res.Y) == 0 {
		res.Y = utl.DblsAlloc(ndim, 0)
	}
	for j := 0; j < ndim; j++ {
		res.Y[j] = append(res.Y[j], y[j])
	}
	return
}
Example #21
0
// FilterPairs generates 2 lists with ninds/2 items each corresponding to selected pairs
// for reprodoction. Repeated indices in pairs are avoided.
//  Input:
//   selinds -- list of selected individuals len(selinds) == ninds
//  Output:
//   A and B -- [ninds/2] lists with pairs
func FilterPairs(A, B []int, selinds []int) {
	ninds := len(selinds)
	chk.IntAssert(len(A), ninds/2)
	chk.IntAssert(len(B), ninds/2)
	var a, b int
	var aux []int
	for i := 0; i < ninds/2; i++ {
		a, b = selinds[2*i], selinds[2*i+1]
		if a == b {
			if len(aux) == 0 {
				aux = rnd.IntGetShuffled(selinds)
			} else {
				rnd.IntShuffle(aux)
			}
			for _, s := range aux {
				if s != a {
					b = s
					break
				}
			}
		}
		A[i], B[i] = a, b
	}
}
Example #22
0
func Test_cubiceq01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("cubiceq01. y(x) = x³ - 3x² - 144x + 432")

	a, b, c := -3.0, -144.0, 432.0
	x1, x2, x3, nx := EqCubicSolveReal(a, b, c)
	io.Pforan("\na=%v b=%v c=%v\n", a, b, c)
	io.Pfcyan("nx=%v\n", nx)
	io.Pfcyan("x1=%v x2=%v x3=%v\n", x1, x2, x3)
	chk.IntAssert(nx, 3)
	chk.Scalar(tst, "x1", 1e-17, x1, -12)
	chk.Scalar(tst, "x2", 1e-17, x2, 12)
	chk.Scalar(tst, "x3", 1e-14, x3, 3)
}
Example #23
0
func Test_simplechromo01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("simplechromo01")

	rnd.Init(0)
	nbases := 2
	for i := 0; i < 10; i++ {
		chromo := SimpleChromo([]float64{1, 10, 100}, nbases)
		io.Pforan("chromo = %v\n", chromo)
		chk.IntAssert(len(chromo), 3*nbases)
		chk.Scalar(tst, "gene0", 1e-14, chromo[0]+chromo[1], 1)
		chk.Scalar(tst, "gene1", 1e-14, chromo[2]+chromo[3], 10)
		chk.Scalar(tst, "gene2", 1e-13, chromo[4]+chromo[5], 100)
	}
}
Example #24
0
// Scaling computes a scaled version of the input slice with results in [0.0, 1.0]
//  Input:
//   x       -- values
//   ds      -- δs value to be added to all 's' values
//   tol     -- tolerance for capturing xmax ≅ xmin
//   reverse -- compute reverse series;
//              i.e. 's' decreases from 1 to 0 while x goes from xmin to xmax
//   useinds -- if (xmax-xmin)<tol, use indices to generate the 's' slice;
//              otherwise, 's' will be filled with δs + zeros
//  Ouptut:
//   s          -- scaled series; pre--allocated with len(s) == len(x)
//   xmin, xmax -- min(x) and max(x)
func Scaling(s, x []float64, ds, tol float64, reverse, useinds bool) (xmin, xmax float64) {
	if len(x) < 2 {
		return
	}
	n := len(x)
	chk.IntAssert(len(s), n)
	xmin, xmax = x[0], x[0]
	for i := 1; i < n; i++ {
		if x[i] < xmin {
			xmin = x[i]
		}
		if x[i] > xmax {
			xmax = x[i]
		}
	}
	dx := xmax - xmin
	if dx < tol {
		if useinds {
			N := float64(n - 1)
			if reverse {
				for i := 0; i < n; i++ {
					s[i] = ds + float64(n-1-i)/N
				}
				return
			}
			for i := 0; i < n; i++ {
				s[i] = ds + float64(i)/N
			}
			return
		}
		for i := 0; i < n; i++ {
			s[i] = ds
		}
		return
	}
	if reverse {
		for i := 0; i < n; i++ {
			s[i] = ds + (xmax-x[i])/dx
		}
		return
	}
	for i := 0; i < n; i++ {
		s[i] = ds + (x[i]-xmin)/dx
	}
	return
}
Example #25
0
// Init initialises graph
//  Input:
//    edges    -- [nedges][2] edges (connectivity)
//    weightsE -- [nedges] weights of edges. can be <nil>
//    verts    -- [nverts][ndim] vertices. can be <nil>
//    weightsV -- [nverts] weights of vertices. can be <nil>
func (o *Graph) Init(edges [][]int, weightsE []float64, verts [][]float64, weightsV []float64) {
	o.Edges, o.WeightsE = edges, weightsE
	o.Verts, o.WeightsV = verts, weightsV
	o.Shares = make(map[int][]int)
	o.Key2edge = make(map[int]int)
	for k, edge := range o.Edges {
		i, j := edge[0], edge[1]
		utl.IntIntsMapAppend(&o.Shares, i, k)
		utl.IntIntsMapAppend(&o.Shares, j, k)
		o.Key2edge[o.HashEdgeKey(i, j)] = k
	}
	if o.Verts != nil {
		chk.IntAssert(len(o.Verts), len(o.Shares))
	}
	nv := len(o.Shares)
	o.Dist = utl.DblsAlloc(nv, nv)
	o.Next = utl.IntsAlloc(nv, nv)
}
Example #26
0
// TextHist prints a text histogram
//  Input:
//   labels -- labels
//   counts -- frequencies
func TextHist(labels []string, counts []int, barlen int) string {

	// check
	chk.IntAssert(len(labels), len(counts))
	if len(counts) < 2 {
		return "counts slice is too short\n"
	}

	// scale
	fmax := counts[0]
	lmax := 0
	Lmax := 0
	for i, f := range counts {
		fmax = imax(fmax, f)
		lmax = imax(lmax, len(labels[i]))
		Lmax = imax(Lmax, len(io.Sf("%d", f)))
	}
	if fmax < 1 {
		return io.Sf("max frequency is too small: fmax=%d\n", fmax)
	}
	scale := float64(barlen) / float64(fmax)

	// print
	sz := io.Sf("%d", lmax+1)
	Sz := io.Sf("%d", Lmax+1)
	l := ""
	total := 0
	for i, f := range counts {
		l += io.Sf("%"+sz+"s | %"+Sz+"d ", labels[i], f)
		n := int(float64(f) * scale)
		if f > 0 { // TODO: improve this
			n += 1
		}
		for j := 0; j < n; j++ {
			l += "#"
		}
		l += "\n"
		total += f
	}
	sz = io.Sf("%d", lmax+3)
	l += io.Sf("%"+sz+"s %"+Sz+"d\n", "count =", total)
	return l
}
Example #27
0
func Test_nurbs04(tst *testing.T) {

	//verbose()
	chk.PrintTitle("nurbs04")

	// NURBS
	a := FactoryNurbs2dPlateHole()
	b := a.KrefineN(2, false)
	c := a.KrefineN(4, false)

	// tolerace for normalised space comparisons
	tol := 1e-7

	// tags
	a_vt := tag_verts(a, tol)
	a_ct := map[string]int{
		"0_0": -1,
		"0_1": -2,
	}
	b_vt := tag_verts(b, tol)
	c_vt := tag_verts(c, tol)

	// write .msh files
	WriteMshD("/tmp/gosl/gm", "m_nurbs04a", []*Nurbs{a}, a_vt, a_ct, tol)
	WriteMshD("/tmp/gosl/gm", "m_nurbs04b", []*Nurbs{b}, b_vt, nil, tol)
	WriteMshD("/tmp/gosl/gm", "m_nurbs04c", []*Nurbs{c}, c_vt, nil, tol)

	// read .msh file back and check
	a_read := ReadMsh("/tmp/gosl/gm/m_nurbs04a")[0]
	chk.IntAssert(a_read.gnd, a.gnd)
	chk.Ints(tst, "p", a.p, a_read.p)
	chk.Ints(tst, "n", a.n, a_read.n)
	chk.Deep4(tst, "Q", 1.0e-17, a.Q, a_read.Q)
	chk.IntMat(tst, "l2i", a.l2i, a_read.l2i)

	// plot
	if chk.Verbose {
		PlotNurbs("/tmp/gosl/gm", "nurbs04a.png", a_read, 41, true, nil)
		PlotTwoNurbs("/tmp/gosl/gm", "nurbs04b.png", a, b, 41, true, nil)
		PlotTwoNurbs("/tmp/gosl/gm", "nurbs04c.png", a, c, 41, true, nil)
	}
}
Example #28
0
// Init initialises the circle
func (o *Circle) Init(xc []float64, r float64) {

	// check: circle works in 2D only
	ndim := 2
	chk.IntAssert(len(xc), ndim)

	// save input data
	o.Xc = make([]float64, ndim)
	copy(o.Xc, xc)
	o.R = r

	// allocate auxiliary variables
	o.Xa = make([]float64, ndim)
	o.Xb = make([]float64, ndim)
	o.e = make([]float64, ndim)
	o.e0 = make([]float64, ndim)
	o.v = make([]float64, ndim)
	o.p = make([]float64, ndim)
	o.q = make([]float64, ndim)
}
Example #29
0
func Test_circint02(tst *testing.T) {

	verbose()
	chk.PrintTitle("circint02. sloped line (increasing). 2 intersec")

	var circ Circle
	xc := []float64{8, 8}
	r := 9.0
	circ.Init(xc, r)

	pa, pb := []float64{4, 2}, []float64{18, 9}
	ni := circ.SegmentIntersect(pa, pb)
	io.Pf("ni = %v\n", ni)
	io.Pf("pa = %v\n", pa)
	io.Pf("pb = %v\n", pb)
	io.Pf("circ.Xa = %v\n", circ.Xa)
	io.Pf("circ.Xb = %v\n", circ.Xb)
	chk.IntAssert(ni, 2)
	chk.Vector(tst, "circ.Xa", 1e-4, circ.Xa, []float64{2.2135, 1.10675})
	chk.Vector(tst, "circ.Xb", 1e-4, circ.Xb, []float64{16.9865, 8.49325})
}
Example #30
0
func Test_circint03(tst *testing.T) {

	verbose()
	chk.PrintTitle("circint03. sloped line (decreasing). 2 intersec")

	var circ Circle
	xc := []float64{5, -5}
	r := 3.0
	circ.Init(xc, r)

	pa, pb := []float64{2, 0}, []float64{9, -11.5}
	ni := circ.SegmentIntersect(pa, pb)
	io.Pf("ni = %v\n", ni)
	io.Pf("pa = %v\n", pa)
	io.Pf("pb = %v\n", pb)
	io.Pf("Xa = %v\n", circ.Xa)
	io.Pf("Xb = %v\n", circ.Xb)
	chk.IntAssert(ni, 2)
	chk.Vector(tst, "Xa", 1e-2, circ.Xa, []float64{3.4719, -2.4181})
	chk.Vector(tst, "Xb", 1e-2, circ.Xb, []float64{6.5917, -7.5435})
}