示例#1
0
func Test_invs04(tst *testing.T) {

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

	a := []float64{-10.0, -20.0, -30.0, 4.0 * SQ2, 5.0 * SQ2, 6.0 * SQ2}
	at := Alloc2()
	Man2Ten(at, a)
	io.Pf("a = %v\n", a)
	chk.Matrix(tst, "Man2Ten", 1e-17, at, [][]float64{
		{-10, 4, 6},
		{4, -20, 5},
		{6, 5, -30},
	})

	b := []float64{-88, -77, -55, -3 * SQ2}
	bt := Alloc2()
	Man2Ten(bt, b)
	io.Pf("b = %v\n", b)
	chk.Matrix(tst, "Man2Ten", 1e-17, bt, [][]float64{
		{-88, -3, 0},
		{-3, -77, 0},
		{0, 0, -55},
	})

	ver := chk.Verbose
	run_invs_tests(tst, a, ver)
	run_invs_tests(tst, b, ver)
}
示例#2
0
func Test_conv06(tst *testing.T) {

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

	a := [][]float64{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9},
		{10, 11, 12},
	}
	a_ := MatAlloc(4, 3)
	am := MatToColMaj(a)
	aa := ColMajToMatNew(am, 4, 3)
	ColMajToMat(a_, am)
	io.Pforan("a  = %v\n", a)
	io.Pforan("am = %v\n", am)
	io.Pforan("aa = %v\n", aa)
	chk.Vector(tst, "a => am", 1e-17, am, []float64{1, 4, 7, 10, 2, 5, 8, 11, 3, 6, 9, 12})
	chk.Matrix(tst, "am => a", 1e-17, aa, a)
	chk.Matrix(tst, "am => a", 1e-17, a_, a)

	b := [][]float64{
		{1, 2, 3, 4},
		{5, 6, 7, 8},
		{9, 0, -1, -2},
	}
	bm := MatToColMaj(b)
	bb := ColMajToMatNew(bm, 3, 4)
	io.Pforan("b  = %v\n", b)
	io.Pforan("bm = %v\n", bm)
	io.Pforan("bb = %v\n", bb)
	chk.Vector(tst, "b => bm", 1e-15, bm, []float64{1, 5, 9, 2, 6, 0, 3, 7, -1, 4, 8, -2})
	chk.Matrix(tst, "bm => b", 1e-15, bb, b)
}
示例#3
0
func Test_matinvSmall01(tst *testing.T) {

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

	noise := 0.0
	tol := 1.0e-16

	// 1 x 1 matrix
	res := MatAlloc(1, 1)
	det, err := MatInv(res, [][]float64{{2.0}}, tol)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	chk.Scalar(tst, "1 x 1 matrix: det ", tol, det, 2.0)
	chk.Matrix(tst, "1 x 1 matrix: ", tol, res, [][]float64{{0.5}})

	// matrix: inverse
	A := [][]float64{{1.0, 2.0}, {3.0, 2.0}}
	Aicorr := [][]float64{{-0.5, 0.5}, {0.75, -0.25 + noise}}
	Ai := MatAlloc(2, 2)
	detA, err := MatInv(Ai, A, tol)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	chk.Scalar(tst, "matrix: inv (det) ", tol, detA, -4.0+noise)
	chk.Matrix(tst, "matrix: inv (A)   ", tol, Ai, Aicorr)

	// using MatInvG
	Ai_ := MatAlloc(2, 2)
	err = MatInvG(Ai_, A, tol)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	chk.Matrix(tst, "matrix: inv with MatInvG", tol, Ai_, Aicorr)

	// another test
	B := [][]float64{{9.0, 3.0, 5.0}, {-6.0, -9.0, 7.0}, {-1.0, -8.0, 1.0}}
	Bicorr := [][]float64{
		{7.642276422764227e-02, -6.991869918699187e-02, 1.073170731707317e-01},
		{-1.626016260162601e-03, 2.276422764227642e-02, -1.512195121951219e-01},
		{6.341463414634146e-02, 1.121951219512195e-01, -1.024390243902439e-01 + noise},
	}
	Bi := MatAlloc(3, 3)
	detB, err := MatInv(Bi, B, tol)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	chk.Scalar(tst, "matrix: det ", tol, detB, 615.0+noise)
	chk.Matrix(tst, "matrix: inv ", tol, Bi, Bicorr)

	// using MatInvG
	Bi_ := MatAlloc(3, 3)
	err = MatInvG(Bi_, B, tol)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	chk.Matrix(tst, "matrix: inv with MatInvG", tol, Bi_, Bicorr)
}
示例#4
0
func Test_mylab01(tst *testing.T) {

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

	I := make([]int, 5)
	IntFill(I, 666)
	J := IntVals(5, 666)
	Js := StrVals(5, "666")
	M := IntsAlloc(3, 4)
	N := DblsAlloc(3, 4)
	S := StrsAlloc(2, 3)
	A := IntRange(-1)
	a := IntRange2(0, 0)
	b := IntRange2(0, 1)
	c := IntRange2(0, 5)
	C := IntRange3(0, -5, -1)
	d := IntRange2(2, 5)
	D := IntRange2(-2, 5)
	e := IntAddScalar(D, 2)
	f := DblOnes(5)
	ff := DblVals(5, 666)
	g := []int{1, 2, 3, 4, 3, 4, 2, 1, 1, 2, 3, 4, 4, 2, 3, 7, 8, 3, 8, 3, 9, 0, 11, 23, 1, 2, 32, 12, 4, 32, 4, 11, 37}
	h := IntUnique(g)
	G := []int{1, 2, 3, 38, 3, 5, 3, 1, 2, 15, 38, 1, 11}
	H := IntUnique(D, C, G, []int{16, 39})
	X, Y := MeshGrid2D(3, 6, 10, 20, 4, 3)
	P := [][]int{
		{1, 2, 3, 4, 5},
		{-1, -2, -3, -4, -5},
		{6, 7, 8, 9, 10},
	}
	Pc := IntsClone(P)
	chk.Ints(tst, "I", I, []int{666, 666, 666, 666, 666})
	chk.Ints(tst, "J", J, []int{666, 666, 666, 666, 666})
	chk.Strings(tst, "Js", Js, []string{"666", "666", "666", "666", "666"})
	chk.Ints(tst, "A", A, []int{})
	chk.Ints(tst, "a", a, []int{})
	chk.Ints(tst, "b", b, []int{0})
	chk.Ints(tst, "c", c, []int{0, 1, 2, 3, 4})
	chk.Ints(tst, "C", C, []int{0, -1, -2, -3, -4})
	chk.Ints(tst, "d", d, []int{2, 3, 4})
	chk.Ints(tst, "D", D, []int{-2, -1, 0, 1, 2, 3, 4})
	chk.Ints(tst, "e", e, []int{0, 1, 2, 3, 4, 5, 6})
	chk.Vector(tst, "f", 1e-16, f, []float64{1, 1, 1, 1, 1})
	chk.Vector(tst, "ff", 1e-16, ff, []float64{666, 666, 666, 666, 666})
	chk.Ints(tst, "h", h, []int{0, 1, 2, 3, 4, 7, 8, 9, 11, 12, 23, 32, 37})
	chk.Ints(tst, "H", H, []int{-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 11, 15, 16, 38, 39})
	chk.IntMat(tst, "M", M, [][]int{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}})
	chk.Matrix(tst, "N", 1e-17, N, [][]float64{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}})
	chk.Matrix(tst, "X", 1e-17, X, [][]float64{{3, 4, 5, 6}, {3, 4, 5, 6}, {3, 4, 5, 6}})
	chk.Matrix(tst, "Y", 1e-17, Y, [][]float64{{10, 10, 10, 10}, {15, 15, 15, 15}, {20, 20, 20, 20}})
	chk.StrMat(tst, "S", S, [][]string{{"", "", ""}, {"", "", ""}})
	chk.IntMat(tst, "Pc", Pc, P)
}
示例#5
0
func Test_tsr02(tst *testing.T) {

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

	F := [][]float64{
		{2, 8.0 / 3.0, 0},
		{0, 2, 0},
		{0, 0.0, 1},
	}
	Fi := Alloc2()
	C := Alloc2()
	b := Alloc2()
	J, err := Inv(Fi, F)
	if err != nil {
		chk.Panic("%v", err)
	}
	RightCauchyGreenDef(C, F)
	LeftCauchyGreenDef(b, F)
	io.Pf("F = %v\n", F)
	io.Pf("C = %v\n", C)
	io.Pf("b = %v\n", b)
	chk.Scalar(tst, "J", 1.0e-17, J, 4.0)
	chk.Matrix(tst, "C", 1.0e-17, C, [][]float64{{36.0 / 9.0, 48.0 / 9.0, 0}, {48.0 / 9.0, 100.0 / 9.0, 0}, {0, 0, 1}})
	chk.Matrix(tst, "b", 1.0e-17, b, [][]float64{{100.0 / 9.0, 48.0 / 9.0, 0}, {48.0 / 9.0, 36.0 / 9.0, 0}, {0, 0, 1}})

	λ, μ := 2.0, 3.0
	σ := Alloc2()
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			σ[i][j] = (λ/J)*math.Log(J)*It[i][j] + (μ/J)*(b[i][j]-It[i][j])
		}
	}

	P := Alloc2()
	S := Alloc2()
	σfromP := Alloc2()
	σfromS := Alloc2()
	CauchyToPK1(P, σ, F, Fi, J)
	CauchyToPK2(S, σ, F, Fi, J)
	PK1ToCauchy(σfromP, P, F, Fi, J)
	PK2ToCauchy(σfromS, S, F, Fi, J)

	io.Pf("σ = %v\n", σ)
	io.Pf("P = %v\n", P)
	io.Pf("S = %v\n", S)
	chk.Matrix(tst, "σfromP", 1.0e-17, σfromP, σ)
	chk.Matrix(tst, "σfromS", 1.0e-14, σfromS, σ)
}
示例#6
0
func Test_conv03(tst *testing.T) {

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

	var K, L, A Triplet
	K.Init(6, 6, 36+2*6) // 2*6 == number of nonzeros in A
	L.Init(6, 6, 36+2*6) // 2*6 == number of nonzeros in A
	for i := 0; i < 6; i++ {
		for j := 0; j < 6; j++ {
			K.Put(i, j, 1000)
			L.Put(i, j, 1000)
		}
	}
	A.Init(2, 3, 6)
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			A.Put(i, j, float64(10*(i+1)+j+1))
		}
	}
	Am := A.ToMatrix(nil)
	Ad := Am.ToDense()
	if chk.Verbose {
		Kd := K.ToMatrix(nil).ToDense()
		Ld := L.ToMatrix(nil).ToDense()
		PrintMat("K", Kd, "%8g", false)
		PrintMat("L", Ld, "%8g", false)
		PrintMat("A", Ad, "%8g", false)
	}
	K.PutMatAndMatT(&A)
	L.PutCCMatAndMatT(Am)
	Kaug := K.ToMatrix(nil).ToDense()
	Laug := L.ToMatrix(nil).ToDense()
	if chk.Verbose {
		PrintMat("K augmented", Kaug, "%8g", false)
		PrintMat("L augmented", Laug, "%8g", false)
	}
	Cor := [][]float64{
		{1000, 1000, 1000, 1011, 1021, 1000},
		{1000, 1000, 1000, 1012, 1022, 1000},
		{1000, 1000, 1000, 1013, 1023, 1000},
		{1011, 1012, 1013, 1000, 1000, 1000},
		{1021, 1022, 1023, 1000, 1000, 1000},
		{1000, 1000, 1000, 1000, 1000, 1000},
	}
	chk.Matrix(tst, "Kaug", 1.0e-17, Kaug, Cor)
	chk.Matrix(tst, "Laug", 1.0e-17, Laug, Cor)
}
示例#7
0
func Test_conv01(tst *testing.T) {

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

	var t Triplet
	t.Init(3, 3, 10)
	t.Put(0, 0, 5.0)
	t.Put(0, 0, 5.0)
	t.Put(0, 1, 11.0)
	t.Put(0, 2, 12.0)
	t.Put(1, 0, 20.0)
	t.Put(1, 1, 21.0)
	t.Put(1, 2, 22.0)
	t.Put(2, 0, 30.0)
	t.Put(2, 1, 31.0)
	t.Put(2, 2, 32.0)
	a := t.ToMatrix(nil)
	ad := a.ToDense()
	if chk.Verbose {
		PrintMat("a", ad, "%5g", false)
	}
	chk.Matrix(tst, "a", 1e-17, ad, [][]float64{
		{10, 11, 12},
		{20, 21, 22},
		{30, 31, 32},
	})
}
示例#8
0
func Test_conv02(tst *testing.T) {

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

	var t Triplet
	t.Init(4, 3, 4*3+2)
	t.Put(0, 0, 1.0)
	t.Put(0, 1, 2.0)
	t.Put(0, 2, 3.0)
	t.Put(1, 0, 4.0)
	t.Put(1, 1, 5.0)
	t.Put(1, 2, 6.0)
	t.Put(2, 0, 7.0)
	t.Put(2, 1, 8.0)
	t.Put(2, 2, 9.0)
	t.Put(3, 0, 4.0)
	t.Put(3, 1, 11.0)
	t.Put(3, 2, 12.0)
	t.Put(3, 0, 3.0) // repeated
	t.Put(3, 0, 3.0) // repeated
	a := t.ToMatrix(nil)
	ad := a.ToDense()
	if chk.Verbose {
		PrintMat("a", ad, "%5g", false)
	}
	chk.Matrix(tst, "a", 1e-17, ad, [][]float64{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9},
		{10, 11, 12},
	})
}
示例#9
0
func Test_mmMul01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("mmMul01. MatrixMatrix multiplication")

	a := [][]float64{
		{1.0, 2.0, 3.0},
		{0.5, 0.75, 1.5},
	}
	b := [][]float64{
		{0.1, 0.5, 0.5, 0.75},
		{0.2, 2.0, 2.0, 2.0},
		{0.3, 0.5, 0.5, 0.5},
	}
	c := MatAlloc(2, 4)
	MatMul(c, 1, a, b) // c := 1*a*b
	io.Pf("a = %v\n", a)
	io.Pf("b = %v\n", b)
	io.Pf("c = %v\n", c)

	ccor := [][]float64{
		{1.4, 6.0, 6.0, 6.25},
		{0.65, 2.5, 2.5, 2.625},
	}
	chk.Matrix(tst, "c", 1.0e-15, c, ccor)
}
示例#10
0
func Test_jacobi01(tst *testing.T) {

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

	A := [][]float64{
		{1, 2, 3},
		{2, 3, 2},
		{3, 2, 2},
	}
	Q := MatAlloc(3, 3)
	v := make([]float64, 3)
	nit, err := Jacobi(Q, v, A)
	if err != nil {
		chk.Panic("Jacobi failed:\n%v", err)
	}
	io.Pforan("number of iterations = %v\n", nit)
	PrintMat("A", A, "%13.8f", false)
	PrintMat("Q", Q, "%13.8f", false)
	PrintVec("v", v, "%13.8f", false)

	chk.Matrix(tst, "Q", 1e-17, Q, [][]float64{
		{7.81993314738381295e-01, 5.26633230856907386e-01, 3.33382506832158143e-01},
		{-7.14394870018381645e-02, 6.07084171793832561e-01, -7.91419742017035133e-01},
		{-6.19179178753124115e-01, 5.95068272145819699e-01, 5.12358171676802088e-01},
	})
	chk.Vector(tst, "v", 1e-17, v, []float64{-1.55809924785903786e+00, 6.69537390404459476e+00, 8.62725343814443657e-01})
}
示例#11
0
func Test_Ts(tst *testing.T) {

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

	nd := test_nd
	for m := 0; m < len(test_nd)-3; m++ {
		//for m := 0; m < 3; m++ {
		A := test_AA[m]
		a := M_Alloc2(nd[m])
		Ten2Man(a, A)
		s := M_Dev(a)
		Ts := M_Alloc4(nd[m])
		M_Ts(Ts, s)
		s2 := M_Alloc2(nd[m])
		ds2ds := M_Alloc4(nd[m])
		M_Sq(s2, s)
		M_SqDeriv(ds2ds, s)
		Ts_ := M_Alloc4(nd[m])
		for i := 0; i < len(a); i++ {
			for j := 0; j < len(a); j++ {
				for k := 0; k < len(a); k++ {
					for l := 0; l < len(a); l++ {
						Ts_[i][j] += Psd[i][k] * ds2ds[k][l] * Psd[l][j]
					}
				}
			}
		}
		chk.Matrix(tst, "Ts", 1e-13, Ts, Ts_)
	}
}
示例#12
0
func Test_tsr03(tst *testing.T) {

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

	a := [][]float64{
		{4.0, 1.0 / SQ2, 0},
		{1.0 / SQ2, 5.0, 0},
		{0, 0, 6.0},
	}
	am := make([]float64, 4)
	aa := Alloc2()
	Ten2Man(am, a)
	Man2Ten(aa, am)
	io.Pf("a  = %v\n", a)
	io.Pf("am = %v\n", am)
	io.Pf("aa = %v\n", aa)
	chk.Matrix(tst, "aa", 1.0e-15, aa, a)

	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			chk.Scalar(tst, fmt.Sprintf("am[%d][%d]", i, j), 1.0e-15, M2T(am, i, j), a[i][j])
		}
	}

	b := [][]float64{
		{4.0, 1.0 / SQ2, 3.0 / SQ2},
		{1.0 / SQ2, 5.0, 2.0 / SQ2},
		{3.0 / SQ2, 2.0 / SQ2, 6.0},
	}
	bm := make([]float64, 6)
	bb := Alloc2()
	Ten2Man(bm, b)
	Man2Ten(bb, bm)
	io.Pf("b  = %v\n", b)
	io.Pf("bm = %v\n", bm)
	io.Pf("bb = %v\n", bb)
	chk.Matrix(tst, "bb", 1.0e-15, bb, b)

	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			chk.Scalar(tst, fmt.Sprintf("bm[%d][%d]", i, j), 1.0e-15, M2T(bm, i, j), b[i][j])
		}
	}
}
示例#13
0
func Test_imap(tst *testing.T) {

	//utl.Tsilent = false
	chk.PrintTitle("Test imap")

	for name, shape := range factory {
		gndim := shape.Gndim
		if gndim == 1 {
			continue
		}

		io.Pfyel("--------------------------------- %-6s---------------------------------\n", name)

		// check inverse mapping
		tol := 1e-14
		noise := 0.01
		if name == "tri10" {
			tol = 1e-14
		}
		if shape.FaceNvertsMax > 2 {
			noise = 0.0
		}
		nverts := shape.Nverts
		C := la.MatAlloc(gndim, nverts)
		s := []float64{rand.Float64(), rand.Float64(), rand.Float64()} // scale factors
		la.MatCopy(C, 1.0, shape.NatCoords)
		_ = tol
		io.Pf("nverts:%v\n", nverts)
		io.Pf("gndim:%v\n", gndim)
		for i := 0; i < gndim; i++ {
			for j := 0; j < nverts; j++ {
				C[i][j] *= s[i]
				C[i][j] += noise * rand.Float64() // noise
			}
		}

		r := make([]float64, 3)
		x := make([]float64, 3)
		R := la.MatAlloc(gndim, nverts)

		for j := 0; j < nverts; j++ {
			for i := 0; i < gndim; i++ {
				x[i] = C[i][j]
			}
			err := shape.InvMap(r, x, C)
			io.Pf("r:%v\n", r)
			_ = err
			for i := 0; i < gndim; i++ {
				R[i][j] = r[i]
			}
		}

		chk.Matrix(tst, "checking", tol, R, shape.NatCoords)

		io.PfGreen("OK\n")
	}
}
示例#14
0
func Test_assemb01(tst *testing.T) {

	chk.PrintTitle("assemb01")

	// grid
	var g Grid2D
	g.Init(1.0, 1.0, 3, 3)

	// equations numbering
	var e Equations
	e.Init(g.N, []int{0, 3, 6})

	// K11 and K12
	var K11, K12 la.Triplet
	InitK11andK12(&K11, &K12, &e)

	// assembly
	F1 := make([]float64, e.N1)
	Assemble(&K11, &K12, F1, nil, &g, &e)

	// check
	K11d := K11.ToMatrix(nil).ToDense()
	K12d := K12.ToMatrix(nil).ToDense()
	K11c := [][]float64{
		{16.0, -4.0, -8.0, 0.0, 0.0, 0.0},
		{-8.0, 16.0, 0.0, -8.0, 0.0, 0.0},
		{-4.0, 0.0, 16.0, -4.0, -4.0, 0.0},
		{0.0, -4.0, -8.0, 16.0, 0.0, -4.0},
		{0.0, 0.0, -8.0, 0.0, 16.0, -4.0},
		{0.0, 0.0, 0.0, -8.0, -8.0, 16.0},
	}
	K12c := [][]float64{
		{-4.0, 0.0, 0.0},
		{0.0, 0.0, 0.0},
		{0.0, -4.0, 0.0},
		{0.0, 0.0, 0.0},
		{0.0, 0.0, -4.0},
		{0.0, 0.0, 0.0},
	}
	chk.Matrix(tst, "K11: ", 1e-16, K11d, K11c)
	chk.Matrix(tst, "K12: ", 1e-16, K12d, K12c)
}
示例#15
0
func RunInvCheck(tst *testing.T, key string, M, CorrectInvM [][]float64, checkI bool, Tol, TolI float64) {
	m, n := len(M), len(M[0])
	Mi := MatAlloc(n, m)
	t0 := time.Now()
	err := MatInvG(Mi, M, 1e-13)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	io.Pfpink("Lapack: time elapsed = %v\n", time.Now().Sub(t0))
	MMi := MatAlloc(m, m)
	MMiM := MatAlloc(m, n)
	MatMul(MMi, 1, M, Mi)   // MMi = M * Mi
	MatMul(MMiM, 1, MMi, M) // MMiM = M * Mi * M == M
	chk.Matrix(tst, io.Sf("%s => Mi - CorrectInvM ", key), Tol, Mi, CorrectInvM)
	chk.Matrix(tst, io.Sf("%s => M*Mi*M = M       ", key), Tol, MMiM, M)
	if checkI {
		I := MatAlloc(m, m)
		MatSetDiag(I, 1)
		chk.Matrix(tst, io.Sf("%s => M*Mi = I         ", key), TolI, MMi, I)
	}
}
示例#16
0
func TestCholesky01(tst *testing.T) {

	chk.PrintTitle("TestCholesky 01")

	a := [][]float64{
		{25.0, 15.0, -5.0},
		{15.0, 18.0, 0.0},
		{-5.0, 0.0, 11.0},
	}

	L := MatAlloc(3, 3)
	Cholesky(L, a) // L is such as A = L * transp(L)
	PrintMat("a", a, "%6g", false)
	PrintMat("L", L, "%6g", false)
	LLt := calc_LLt(L)
	chk.Matrix(tst, "a = LLt", 1e-17, LLt, a)
	chk.Matrix(tst, "L", 1e-17, L, [][]float64{
		{5, 0, -0},
		{3, 3, 0},
		{-1, 1, 3},
	})
}
示例#17
0
func main() {

	mpi.Start(false)
	defer func() {
		mpi.Stop(false)
	}()

	if mpi.Rank() == 0 {
		chk.PrintTitle("Test SumToRoot 01")
	}

	M := [][]float64{
		{1000, 1000, 1000, 1011, 1021, 1000},
		{1000, 1000, 1000, 1012, 1022, 1000},
		{1000, 1000, 1000, 1013, 1023, 1000},
		{1011, 1012, 1013, 1000, 1000, 1000},
		{1021, 1022, 1023, 1000, 1000, 1000},
		{1000, 1000, 1000, 1000, 1000, 1000},
	}

	id, sz, m := mpi.Rank(), mpi.Size(), len(M)
	start, endp1 := (id*m)/sz, ((id+1)*m)/sz

	if sz > 6 {
		chk.Panic("this test works with at most 6 processors")
	}

	var J la.Triplet
	J.Init(m, m, m*m)
	for i := start; i < endp1; i++ {
		for j := 0; j < m; j++ {
			J.Put(i, j, M[i][j])
		}
	}
	la.PrintMat(fmt.Sprintf("J @ proc # %d", id), J.ToMatrix(nil).ToDense(), "%10.1f", false)

	la.SpTriSumToRoot(&J)
	var tst testing.T
	if mpi.Rank() == 0 {
		chk.Matrix(&tst, "J @ proc 0", 1.0e-17, J.ToMatrix(nil).ToDense(), [][]float64{
			{1000, 1000, 1000, 1011, 1021, 1000},
			{1000, 1000, 1000, 1012, 1022, 1000},
			{1000, 1000, 1000, 1013, 1023, 1000},
			{1011, 1012, 1013, 1000, 1000, 1000},
			{1021, 1022, 1023, 1000, 1000, 1000},
			{1000, 1000, 1000, 1000, 1000, 1000},
		})
	}
}
示例#18
0
func TestCholesky02(tst *testing.T) {

	chk.PrintTitle("TestCholesky 02")

	a := [][]float64{
		{2, 1, 1, 3, 2},
		{1, 2, 2, 1, 1},
		{1, 2, 9, 1, 5},
		{3, 1, 1, 7, 1},
		{2, 1, 5, 1, 8},
	}
	L := MatAlloc(5, 5)
	Cholesky(L, a)
	PrintMat("a", a, "%6g", false)
	PrintMat("L", L, "%10.6f", false)
	chk.Matrix(tst, "a = LLt", 1e-15, calc_LLt(L), a)
	chk.Matrix(tst, "L", 1e-15, L, [][]float64{
		{math.Sqrt2, 0, 0, 0, 0},
		{1.0 / math.Sqrt2, math.Sqrt(3.0 / 2.0), 0, 0, 0},
		{1.0 / math.Sqrt2, math.Sqrt(3.0 / 2.0), math.Sqrt(7.0), 0, 0},
		{3.0 / math.Sqrt2, -1.0 / math.Sqrt(6.0), 0, math.Sqrt(7.0 / 3.0), 0},
		{math.Sqrt2, 0, 4.0 / math.Sqrt(7.0), -2.0 * math.Sqrt(3.0/7.0), math.Sqrt2},
	})
}
示例#19
0
func TestSparseLA09(tst *testing.T) {

	chk.PrintTitle("TestSparse LA09")

	var a Triplet
	SpTriSetDiag(&a, 4, 666.0)
	A := a.ToMatrix(nil).ToDense()
	PrintMat("diag(4) with 666 =", A, "%8g", false)
	chk.Matrix(tst, "a", 1e-17, A, [][]float64{
		{666, 0, 0, 0},
		{0, 666, 0, 0},
		{0, 0, 666, 0},
		{0, 0, 0, 666},
	})
}
示例#20
0
func Test_serial03(tst *testing.T) {

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

	a := [][]float64{
		{1, 2, 3, 4},
		{5, 6, 7, 8},
		{9, 0, -1, -2},
	}
	v := DblMatToArray(a)
	b := DblArrayToMat(v, 3, 4)
	io.Pforan("a => v = %v\n", v)
	io.Pforan("v => a = %v\n", b)
	chk.Vector(tst, "a => v", 1e-15, v, []float64{1, 5, 9, 2, 6, 0, 3, 7, -1, 4, 8, -2})
	chk.Matrix(tst, "v => a", 1e-15, b, a)
}
示例#21
0
func TestSparseLA07(tst *testing.T) {

	//verbose()
	chk.PrintTitle("TestSparse LA07")

	var ta Triplet
	ta.Init(5, 6, 9)
	ta.Put(0, 0, 1)
	ta.Put(2, 0, 2)
	ta.Put(4, 0, 3)
	ta.Put(1, 2, 3)
	ta.Put(3, 2, 1)
	ta.Put(0, 3, 1)
	ta.Put(4, 3, 5)
	ta.Put(0, 5, 7)
	ta.Put(2, 5, 8)
	io.Pf("ta = %+v\n", ta)

	var tb Triplet
	tb.Init(5, 6, 12)
	tb.Put(1, 1, 1)
	tb.Put(3, 1, 8)
	tb.Put(0, 2, 1)
	tb.Put(1, 2, 2)
	tb.Put(2, 2, 3)
	tb.Put(3, 2, 4)
	tb.Put(4, 2, 5)
	tb.Put(2, 4, 5)
	tb.Put(0, 5, 1)
	tb.Put(1, 5, 4)
	tb.Put(2, 5, 2)
	tb.Put(4, 5, 1)
	io.Pf("tb = %+v\n", tb)

	var tc Triplet
	tc.Init(5, 6, ta.Len()+tb.Len())
	SpTriAdd(&tc, 0.1, &ta, 2, &tb)
	io.Pf("tc = %+v\n", tc)
	chk.Matrix(tst, "c", 1e-16, tc.ToMatrix(nil).ToDense(), [][]float64{
		{0.1, 0, 2.0, 0.1, 0, 2.7},
		{0, 2, 4.3, 0, 0, 8.0},
		{0.2, 0, 6.0, 0, 10, 4.8},
		{0, 16, 8.1, 0, 0, 0.0},
		{0.3, 0, 10.0, 0.5, 0, 2.0},
	})
}
示例#22
0
func TestReadMatrix01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("ReadMatrix 01")

	res, err := ReadMatrix("data/mat01.dat")
	if err != nil {
		tst.Errorf("file cannot be read:\n%v\n", err.Error())
	}

	chk.Matrix(tst, "mat", 1.0e-17, res, [][]float64{
		{1, 2, 3, 4},
		{10, 20, 30, 40},
		{-1, -2, -3, -4},
	})

	Pforan("res = %v\n", res)
}
示例#23
0
func TestSparseLA04(tst *testing.T) {

	chk.PrintTitle("TestSparse LA04")

	var ta Triplet
	ta.Init(3, 3, 4)
	ta.Put(0, 0, 1.0)
	ta.Put(1, 0, 2.0)
	ta.Put(2, 1, 3.0)
	ta.Put(2, 2, 4.0)
	a := ta.ToMatrix(nil)
	io.Pf("a = %+v\n", a)
	PrintMat("a", a.ToDense(), "%2g ", false)
	chk.Vector(tst, "a.x", 1e-17, a.x, []float64{1, 2, 3, 4})
	chk.Ints(tst, "a.i", a.i, []int{0, 1, 2, 2})
	chk.Ints(tst, "a.p", a.p, []int{0, 2, 3, 4})

	var tb Triplet
	tb.Init(3, 3, 4)
	tb.Put(1, 0, 3.0)
	tb.Put(0, 1, 2.0)
	tb.Put(1, 2, 1.0)
	tb.Put(2, 2, 1.0)
	b := tb.ToMatrix(nil)
	io.Pf("b = %+v\n", b)
	PrintMat("b", b.ToDense(), "%2g ", false)
	chk.Vector(tst, "b.x", 1e-17, b.x, []float64{3, 2, 1, 1})
	chk.Ints(tst, "b.i", b.i, []int{1, 0, 1, 2})
	chk.Ints(tst, "b.p", b.p, []int{0, 1, 2, 4})

	c, a2c, b2c := SpAllocMatAddMat(a, b)
	SpMatAddMat(c, 1, a, 1, b, a2c, b2c)
	io.Pf("c = %+v\n", c)
	PrintMat("c", c.ToDense(), "%2g ", false)
	chk.Vector(tst, "c.x", 1e-17, c.x, []float64{1, 5, 2, 3, 1, 5})
	chk.Ints(tst, "c.i", c.i, []int{0, 1, 0, 2, 1, 2})
	chk.Ints(tst, "c.p", c.p, []int{0, 2, 4, 6})
	chk.Ints(tst, "a2c", a2c, []int{0, 1, 3, 5})
	chk.Ints(tst, "b2c", b2c, []int{1, 2, 4, 5})
	chk.Matrix(tst, "c", 1e-17, c.ToDense(), [][]float64{{1, 2, 0}, {5, 0, 1}, {0, 3, 5}})
}
示例#24
0
func Test_elast02(tst *testing.T) {

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

	//K, G := 2.0, 3.0/4.0
	K, G := 1116.6666666666667, 837.5
	io.Pfgreen("K = %v\n", Calc_K_from_Enu(2010, 0.2))
	io.Pfgreen("G = %v\n", Calc_G_from_Knu(K, 0.2))

	ndim, pstress := 2, false
	var ec SmallElasticity
	err := ec.Init(ndim, pstress, []*fun.Prm{
		&fun.Prm{N: "K", V: K},
		&fun.Prm{N: "G", V: G},
	})
	io.Pforan("ec: %+v\n", &ec)
	if err != nil {
		tst.Errorf("test failed: %v\n", err)
		return
	}

	nsig, nalp, large, nle := 2*ndim, 0, false, false
	state := NewState(nsig, nalp, large, nle)

	D := la.MatAlloc(nsig, nsig)
	ec.CalcD(D, state)

	a := K + 4.0*G/3.0
	b := K - 2.0*G/3.0
	c := 2.0 * G
	chk.Matrix(tst, "D", 1e-12, D, [][]float64{
		{a, b, b, 0},
		{b, a, b, 0},
		{b, b, a, 0},
		{0, 0, 0, c},
	})
}
示例#25
0
func Test_spset01(tst *testing.T) {

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

	//          ↓     ↓        ↓           ↓  ↓     ↓
	//          0  1  2  3  4  5  6  7  8  9 10 11 12
	Ai := []int{0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4}
	Ax := []float64{2, 3, 3, -1, 4, 4, -3, 1, 2, 2, 6, 1}
	Ap := []int{0, 2, 5, 9, 10, 12}
	var A CCMatrix
	A.Set(5, 5, Ap, Ai, Ax)
	Ad := A.ToDense()
	PrintMat("A", Ad, "%5g", false)

	chk.Matrix(tst, "A", 1e-17, Ad, [][]float64{
		{2, 3, 0, 0, 0},
		{3, 0, 4, 0, 6},
		{0, -1, -3, 2, 0},
		{0, 0, 1, 0, 0},
		{0, 4, 2, 0, 1},
	})
}
示例#26
0
func RunSvdCheck(tst *testing.T, key string, A, CorU [][]float64, CorS []float64, CorVt [][]float64, Tol float64) {
	m, n := len(A), len(A[0])
	ns := imin(m, n)
	U, S, Vt := MatAlloc(m, m), make([]float64, ns), MatAlloc(n, n)
	err := MatSvd(U, S, Vt, A, 1e-14)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	// TODO: check why U and Vt do not work in some systems => probably
	//       the local linear solver is sorting components in a different way
	//chk.Matrix(tst, io.Sf("%s => U", key), Tol, U, CorU)
	chk.Vector(tst, io.Sf("%s => S", key), Tol, S, CorS)
	//chk.Matrix(tst, io.Sf("%s => Vt", key), Tol, Vt, CorVt)
	usvt := MatAlloc(m, n)
	for i := 0; i < m; i++ {
		for j := 0; j < n; j++ {
			for k := 0; k < ns; k++ {
				usvt[i][j] += U[i][k] * S[k] * Vt[k][j]
			}
		}
	}
	chk.Matrix(tst, io.Sf("%s => U*S*Vt", key), Tol, A, usvt)
}
示例#27
0
func Test_cond01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("cond01. condition number of matrix using general inverse")

	a := [][]float64{
		{1, 2},
		{2, 3.999},
	}
	cIa, err := MatCondG(a, "I", 1e-10)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	ai := MatAlloc(2, 2)
	_, err = MatInv(ai, a, 1e-10)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	nIa := MatNormI(a)
	nIai := MatNormI(ai)
	PrintMat("a", a, "%10g", false)
	PrintMat("ai", ai, "%20g", false)
	io.Pforan("normI(a)  = %v\n", nIa)
	io.Pforan("normI(ai) = %v\n", nIai)
	io.Pforan("cond(a,I) = %v\n", cIa)
	chk.Matrix(tst, "ai       ", 1e-9, ai, [][]float64{{-3999, 2000}, {2000, -1000}})
	chk.Scalar(tst, "normI(a) ", 1e-15, nIa, 5.999)
	chk.Scalar(tst, "normI(ai)", 1e-9, nIai, 5999)
	chk.Scalar(tst, "condI(a) ", 1e-8, cIa, 35988.001)

	b := [][]float64{
		{1, 2},
		{2, 3},
	}
	bi := MatAlloc(2, 2)
	_, err = MatInv(bi, b, 1e-10)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	cIb, err := MatCondG(b, "I", 1e-10)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	cIbi, err := MatCondG(bi, "I", 1e-10)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	cFb, err := MatCondG(b, "F", 1e-10)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	cFbi, err := MatCondG(bi, "F", 1e-10)
	if err != nil {
		chk.Panic("%v", err.Error())
	}
	PrintMat("\nb", b, "%10g", false)
	io.Pforan("cond(b, I) = %v\n", cIb)
	io.Pforan("cond(bi,I) = %v\n", cIbi)
	io.Pforan("cond(b, F) = %v\n", cFb)
	io.Pforan("cond(bi,F) = %v\n", cFbi)
	chk.Matrix(tst, "bi       ", 1e-17, bi, [][]float64{{-3, 2}, {2, -1}})
	chk.Scalar(tst, "condI(b) ", 1e-17, cIb, 25.0)
	chk.Scalar(tst, "condF(b) ", 1e-14, cFb, 18.0)
}
示例#28
0
// testing_compare_results_u compares results with u-formulation
func TestingCompareResultsU(tst *testing.T, simfname, cmpfname string, tolK, tolu, tols float64, skipK, verbose bool) {

	// only root can run this test
	if !Global.Root {
		return
	}

	// read summary
	sum := ReadSum(Global.Dirout, Global.Fnkey)
	if sum == nil {
		tst.Error("cannot read summary file for simulation=%q\n", simfname)
		return
	}

	// allocate domain
	distr := false
	d := NewDomain(Global.Sim.Regions[0], distr)
	if !d.SetStage(0, Global.Sim.Stages[0], distr) {
		tst.Errorf("TestingCompareResultsU: SetStage failed\n")
		return
	}

	// read file
	buf, err := io.ReadFile(cmpfname)
	if err != nil {
		tst.Errorf("TestingCompareResultsU: ReadFile failed\n")
		return
	}

	// unmarshal json
	var cmp_set T_results_set
	err = json.Unmarshal(buf, &cmp_set)
	if err != nil {
		tst.Errorf("TestingCompareResultsU: Unmarshal failed\n")
		return
	}

	// run comparisons
	dmult := 1.0
	for idx, cmp := range cmp_set {

		// displacements multiplier
		if idx == 0 && math.Abs(cmp.DispMult) > 1e-10 {
			dmult = cmp.DispMult
		}

		// time index
		tidx := idx + 1
		if verbose {
			io.PfYel("\n\ntidx = %d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .\n", tidx)
		}

		// load gofem results
		if !d.In(sum, tidx, true) {
			tst.Errorf("TestingCompareResultsU: reading of results failed\n")
			return
		}
		if verbose {
			io.Pfyel("time = %v\n", d.Sol.T)
		}

		// check K matrices
		if !skipK {
			if verbose {
				io.Pfgreen(". . . checking K matrices . . .\n")
			}
			for eid, Ksg := range cmp.Kmats {
				if e, ok := d.Elems[eid].(*ElemU); ok {
					if !e.AddToKb(d.Kb, d.Sol, true) {
						tst.Errorf("TestingCompareResultsU: AddToKb failed\n")
						return
					}
					chk.Matrix(tst, io.Sf("K%d", eid), tolK, e.K, Ksg)
				}
			}
		}

		// check displacements
		if verbose {
			io.Pfgreen(". . . checking displacements . . .\n")
		}
		for nid, usg := range cmp.Disp {
			ix := d.Vid2node[nid].Dofs[0].Eq
			iy := d.Vid2node[nid].Dofs[1].Eq
			chk.AnaNum(tst, "ux", tolu, d.Sol.Y[ix], usg[0]*dmult, verbose)
			chk.AnaNum(tst, "uy", tolu, d.Sol.Y[iy], usg[1]*dmult, verbose)
			if len(usg) == 3 {
				iz := d.Vid2node[nid].Dofs[2].Eq
				chk.AnaNum(tst, "uz", tolu, d.Sol.Y[iz], usg[2]*dmult, verbose)
			}
		}

		// check stresses
		if true {
			if verbose {
				io.Pfgreen(". . . checking stresses . . .\n")
			}
			for eid, sig := range cmp.Sigmas {
				if verbose {
					io.Pforan("eid = %d\n", eid)
				}
				if e, ok := d.Cid2elem[eid].(*ElemU); ok {
					for ip, val := range sig {
						if verbose {
							io.Pfgrey2("ip = %d\n", ip)
						}
						σ := e.States[ip].Sig
						if len(val) == 6 {
							chk.AnaNum(tst, "sx ", tols, σ[0], val[0], verbose)
							chk.AnaNum(tst, "sy ", tols, σ[1], val[1], verbose)
						} else {
							chk.AnaNum(tst, "sx ", tols, σ[0], val[0], verbose)
							chk.AnaNum(tst, "sy ", tols, σ[1], val[1], verbose)
							chk.AnaNum(tst, "sxy", tols, σ[3]/SQ2, val[2], verbose)
							if len(val) > 3 { // sx, sy, sxy, sz
								chk.AnaNum(tst, "sz ", tols, σ[2], val[3], verbose)
							}
						}
					}
				}
			}
		}
	}
}
示例#29
0
func Test_mylab01(tst *testing.T) {

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

	I := make([]int, 5)
	IntFill(I, 666)
	J := IntVals(5, 666)
	Js := StrVals(5, "666")
	M := IntsAlloc(3, 4)
	N := DblsAlloc(3, 4)
	A := IntRange(-1)
	a := IntRange2(0, 0)
	b := IntRange2(0, 1)
	c := IntRange2(0, 5)
	C := IntRange3(0, -5, -1)
	d := IntRange2(2, 5)
	D := IntRange2(-2, 5)
	e := IntAddScalar(D, 2)
	f := DblOnes(5)
	ff := DblVals(5, 666)
	g := []int{1, 2, 3, 4, 3, 4, 2, 1, 1, 2, 3, 4, 4, 2, 3, 7, 8, 3, 8, 3, 9, 0, 11, 23, 1, 2, 32, 12, 4, 32, 4, 11, 37}
	h := IntUnique(g)
	G := []int{1, 2, 3, 38, 3, 5, 3, 1, 2, 15, 38, 1, 11}
	H := IntUnique(D, C, G, []int{16, 39})
	X, Y := MeshGrid2D(3, 6, 10, 20, 4, 3)
	io.Pf("I  = %v\n", I)
	io.Pf("Js = %v\n", Js)
	io.Pf("J  = %v\n", J)
	io.Pf("A  = %v\n", A)
	io.Pf("a  = %v\n", a)
	io.Pf("b  = %v\n", b)
	io.Pf("c  = %v\n", c)
	io.Pf("C  = %v\n", C)
	io.Pf("d  = %v\n", d)
	io.Pf("D  = %v\n", D)
	io.Pf("e  = %v\n", e)
	io.Pf("f  = %v\n", f)
	io.Pf("G  = %v\n", G)
	io.Pf("H  = %v\n", H)
	io.Pf("g  = %v\n", g)
	io.Pf("h  = %v\n", h)
	io.Pf("M  = %v\n", M)
	io.Pf("N  = %v\n", N)
	io.Pf("X  = %v\n", X)
	io.Pf("Y  = %v\n", Y)
	chk.Ints(tst, "I", I, []int{666, 666, 666, 666, 666})
	chk.Ints(tst, "J", J, []int{666, 666, 666, 666, 666})
	chk.Strings(tst, "Js", Js, []string{"666", "666", "666", "666", "666"})
	chk.Ints(tst, "A", A, []int{})
	chk.Ints(tst, "a", a, []int{})
	chk.Ints(tst, "b", b, []int{0})
	chk.Ints(tst, "c", c, []int{0, 1, 2, 3, 4})
	chk.Ints(tst, "C", C, []int{0, -1, -2, -3, -4})
	chk.Ints(tst, "d", d, []int{2, 3, 4})
	chk.Ints(tst, "D", D, []int{-2, -1, 0, 1, 2, 3, 4})
	chk.Ints(tst, "e", e, []int{0, 1, 2, 3, 4, 5, 6})
	chk.Vector(tst, "f", 1e-16, f, []float64{1, 1, 1, 1, 1})
	chk.Vector(tst, "ff", 1e-16, ff, []float64{666, 666, 666, 666, 666})
	chk.Ints(tst, "h", h, []int{0, 1, 2, 3, 4, 7, 8, 9, 11, 12, 23, 32, 37})
	chk.Ints(tst, "H", H, []int{-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 11, 15, 16, 38, 39})
	chk.IntMat(tst, "M", M, [][]int{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}})
	chk.Matrix(tst, "N", 1e-17, N, [][]float64{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}})
	chk.Matrix(tst, "X", 1e-17, X, [][]float64{{3, 4, 5, 6}, {3, 4, 5, 6}, {3, 4, 5, 6}})
	chk.Matrix(tst, "Y", 1e-17, Y, [][]float64{{10, 10, 10, 10}, {15, 15, 15, 15}, {20, 20, 20, 20}})
}
示例#30
0
func Test_ops03(tst *testing.T) {

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

	nonsymTol := 1e-15

	dtol := 1e-9
	dver := chk.Verbose

	nd := test_nd
	for idxA := 0; idxA < len(test_nd)-3; idxA++ {
		//for idxA := 0; idxA < 1; idxA++ {

		// tensor and eigenvalues
		A := test_AA[idxA]
		a := M_Alloc2(nd[idxA])
		Ten2Man(a, A)
		io.PfYel("\n\ntst # %d ###################################################################################\n", idxA)
		io.Pfblue2("a = %v\n", a)

		// inverse
		Ai := Alloc2()
		ai := M_Alloc2(nd[idxA])
		detA, err := Inv(Ai, A)
		if err != nil {
			chk.Panic("%v", err)
		}
		deta_ := M_Det(a)
		deta, err := M_Inv(ai, a, MINDET)
		if err != nil {
			chk.Panic("%v", err)
		}
		Ai_ := Alloc2()
		Man2Ten(Ai_, ai)
		aia := M_Alloc2(nd[idxA])
		err = M_Dot(aia, ai, a, nonsymTol)
		if err != nil {
			chk.Panic("%v", err)
		}
		chk.Scalar(tst, "detA", 1e-14, detA, deta)
		chk.Scalar(tst, "deta", 1e-14, deta, deta_)
		chk.Matrix(tst, "Ai", 1e-14, Ai, Ai_)
		chk.Vector(tst, "ai*a", 1e-15, aia, Im[:2*nd[idxA]])
		io.Pforan("ai*a = %v\n", aia)

		// derivative of inverse
		dtol_tmp := dtol
		if idxA == 5 {
			dtol = 1e-8
		}
		var tmp float64
		ai_tmp := M_Alloc2(nd[idxA])
		daida := M_Alloc4(nd[idxA])
		M_InvDeriv(daida, ai)
		io.Pforan("ai = %v\n", ai)
		for i := 0; i < len(a); i++ {
			for j := 0; j < len(a); j++ {
				//dnum, _ := num.DerivForward(func(x float64, args ...interface{}) (res float64) {
				dnum, _ := num.DerivCentral(func(x float64, args ...interface{}) (res float64) {
					tmp, a[j] = a[j], x
					_, err := M_Inv(ai_tmp, a, MINDET)
					a[j] = tmp
					if err != nil {
						chk.Panic("daida failed:\n%v", err)
					}
					return ai_tmp[i]
				}, a[j], 1e-6)
				chk.AnaNum(tst, io.Sf("dai/da[%d][%d]", i, j), dtol, daida[i][j], dnum, dver)
			}
		}
		dtol = dtol_tmp
	}
}