diff --git a/task7/8-nets.png b/task7/8-nets.png new file mode 100644 index 0000000..a9c04c5 Binary files /dev/null and b/task7/8-nets.png differ diff --git a/task7/8-newCollocation.png b/task7/8-newCollocation.png new file mode 100644 index 0000000..e726941 Binary files /dev/null and b/task7/8-newCollocation.png differ diff --git a/task7/8-ritz.png b/task7/8-ritz.png new file mode 100644 index 0000000..ddd6c40 Binary files /dev/null and b/task7/8-ritz.png differ diff --git a/task7/deltas.png b/task7/deltas.png new file mode 100644 index 0000000..b15d831 Binary files /dev/null and b/task7/deltas.png differ diff --git a/task7/functions.png b/task7/functions.png new file mode 100644 index 0000000..bfd4a83 Binary files /dev/null and b/task7/functions.png differ diff --git a/task7/go.mod b/task7/go.mod new file mode 100644 index 0000000..37d16e6 --- /dev/null +++ b/task7/go.mod @@ -0,0 +1,14 @@ +module workshop/task7 + +go 1.22.1 + +require ( + github.com/wcharczuk/go-chart/v2 v2.1.1 + gonum.org/v1/gonum v0.15.0 +) + +require ( + github.com/blend/go-sdk v1.20220411.3 // indirect + github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect + golang.org/x/image v0.14.0 // indirect +) diff --git a/task7/go.sum b/task7/go.sum new file mode 100644 index 0000000..86b12dc --- /dev/null +++ b/task7/go.sum @@ -0,0 +1,44 @@ +github.com/blend/go-sdk v1.20220411.3 h1:GFV4/FQX5UzXLPwWV03gP811pj7B8J2sbuq+GJQofXc= +github.com/blend/go-sdk v1.20220411.3/go.mod h1:7lnH8fTi6U4i1fArEXRyOIY2E1X4MALg09qsQqY1+ak= +github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g= +github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= +github.com/wcharczuk/go-chart/v2 v2.1.1 h1:2u7na789qiD5WzccZsFz4MJWOJP72G+2kUuJoSNqWnE= +github.com/wcharczuk/go-chart/v2 v2.1.1/go.mod h1:CyCAUt2oqvfhCl6Q5ZvAZwItgpQKZOkCJGb+VGv6l14= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= +golang.org/x/image v0.11.0/go.mod h1:bglhjqbqVuEb9e9+eNR45Jfu7D+T4Qan+NhQk8Ck2P8= +golang.org/x/image v0.14.0 h1:tNgSxAFe3jC4uYqvZdTr84SZoM1KfwdC9SKIFrLjFn4= +golang.org/x/image v0.14.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gonum.org/v1/gonum v0.15.0 h1:2lYxjRbTYyxkJxlhC+LvJIx3SsANPdRybu1tGj9/OrQ= +gonum.org/v1/gonum v0.15.0/go.mod h1:xzZVBJBtS+Mz4q0Yl2LJTk+OxOg4jiXZ7qBoM0uISGo= diff --git a/task7/main.go b/task7/main.go new file mode 100644 index 0000000..a3c2fba --- /dev/null +++ b/task7/main.go @@ -0,0 +1,78 @@ +package main + +import ( + "fmt" + "math" +) + +// коэффициент при u” +func p(x float64) float64 { + return -(5.0 - x) / (7.0 - 3.0*x) +} + +// коэффициент при u' +func q(x float64) float64 { + return -(1.0 - x) / 2.0 +} + +// коэффициент при u +func r(x float64) float64 { + return 1.0 + 0.5*math.Sin(x) +} + +// правая часть дифференциального уравнения +func f(x float64) float64 { + return 0.5 + x/2.0 +} + +// ___ +// коэффициент при y' +func p8(x float64) float64 { + return (2.0 + x) / (3.0 + x) +} + +// коэффициент при y +func r8(x float64) float64 { + return 1.0 + math.Sin(x) +} + +func q8(float64) float64 { + return 0.0 +} + +// правая часть дифференциального уравнения +func f8(x float64) float64 { + return 1.0 - x +} + +func main() { + var task int + fmt.Scanf("%d\n", &task) + if task == 7 { + a, b, typeF, eps, alpha1, alpha2, alpha, beta1, beta2, beta := -1.0, 1.0, 1, 1e-4, 0.0, 1.0, 0.0, 3.0, 2.0, 0.0 + x_d, net_d, delta_d, n_d := solveTask(p, q, r, f, a, b, typeF, eps, alpha1, alpha2, alpha, beta1, beta2, beta) + fmt.Println("Variant 10. Approximation results are in 'nets.png' and 'deltas.png'") + drowGraphic(x_d, net_d, n_d, "nets") + drowGraphic(x_d, delta_d, n_d, "deltas") + } else { + alpha1, alpha2, beta1, beta2 := 0.0, 1.0, 1.0, 1.0 + typeF := 0 + if alpha1*alpha2*beta1*beta2 != 0 { + typeF = 3 + } + if alpha1*alpha2 != 0 { + typeF = 1 + } + if beta2*beta2 != 0 { + typeF = 2 + } + a, b, eps, alpha, beta := -1.0, 1.0, 2e-4, 0.0, 0.0 + x_d, net_d, _, n_d := solveTask(p8, q8, r8, f8, a, b, 2, eps, alpha1, alpha2, alpha, beta1, beta2, beta) + fmt.Println("Сравнение с методом сеток. Результат в '8-nets.png'") + drowGraphic(x_d, net_d, n_d, "8-nets") + fmt.Println("Вычисляем методом Ритца при разных n. Результат в '8-ritz.png'") + solveRitz(p8, r8, f8, typeF, alpha1, alpha2, beta1, beta2) + fmt.Println("Вычисляем методом коллокации при разных n. Результат в '8-newCollocation.png'") + solveCol(p8, r8, f8) + } +} diff --git a/task7/nets.png b/task7/nets.png new file mode 100644 index 0000000..31fb611 Binary files /dev/null and b/task7/nets.png differ diff --git a/task7/newCollocation.go b/task7/newCollocation.go new file mode 100644 index 0000000..ccd78bb --- /dev/null +++ b/task7/newCollocation.go @@ -0,0 +1,94 @@ +package main + +import ( + "gonum.org/v1/gonum/mat" +) + +func wi(_ float64, i int) Funct { + a := Funct{func(x float64) float64 { + return (1.0 - x*x) * (1.0 - x*x) + }} + return a.Mul(Funct{getP(2, i-2)}) +} + +func wpi(_ float64, i int) Funct { + a := Funct{func(x float64) float64 { + return -2.0 * (float64(i) - 1.0) * (1.0 - x*x) * (1.0 - x*x) + }} + return a.Mul(Funct{getP(1, i-1)}) +} + +func wppi(_ float64, i int) Funct { + a := Funct{func(float64) float64 { + return 4.0 * (float64(i) - 1.0) * float64(i) + }} + return a.Mul(Funct{getP(0, i)}) +} + +func getW(n int) [][]Funct { + res := make([][]Funct, n+1) + res[0] = []Funct{{func(x float64) float64 { + return x*x + 2.0*x - 7.0 + }}, {func(x float64) float64 { + return 2.0*x + 2.0 + }}, {func(float64) float64 { + return 2.0 + }}} + res[1] = []Funct{{func(x float64) float64 { + return x*x*x - 3.0*x + 2.0 + }}, {func(x float64) float64 { + return 3.0*x*x - 3.0 + }}, {func(x float64) float64 { + return 6.0 * x + }}} + + for i := 2; i < n+1; i++ { + res[i] = []Funct{{func(x float64) float64 { + return wi(x, i).f(x) + }}, {func(x float64) float64 { + return wpi(x, i).f(x) + }}, {func(x float64) float64 { + return wppi(x, i).f(x) + }}} + } + return res +} + +func solveCol(p, r, f func(float64) float64) { + xrand := make([][]float64, 5) + frand := make([][]float64, 5) + ns := make([]int, 5) + ind := 0 + for n := 4; n < 14; n += 2 { + xrand[ind] = makeNet(-1, 1, n*10) + dots := makeNet(-1, 1, n) + a := mat.NewDense(n+1, n+1, nil) + b := mat.NewVecDense(n+1, nil) + coord := getW(n) + for i := 0; i < n+1; i++ { + x := dots[i] + for j := 0; j < n+1; j++ { + a.Set(i, j, -p(x)*coord[j][2].f(x)+q(x)*coord[j][1].f(x)+r(x)*coord[j][0].f(x)) + } + b.SetVec(i, f(x)) + } + res := mat.NewVecDense(n+1, nil) + res.SolveVec(a, b) + y := Funct{func(x float64) float64 { + return 0.0 + }} + for i := 0; i < n+1; i++ { + fa := Funct{func(x float64) float64 { + return res.AtVec(i) * coord[i][0].f(x) + }} + y = y.Add(fa) + } + frand[ind] = make([]float64, n*10+1) + for i := 0; i < n*10+1; i++ { + frand[ind][i] = y.f(xrand[ind][i]) + } + ns[ind] = n + 1 + ind++ + } + drowGraphic(xrand, frand, ns, "8-newCollocation") +} diff --git a/task7/richardson.go b/task7/richardson.go new file mode 100644 index 0000000..2be7d2b --- /dev/null +++ b/task7/richardson.go @@ -0,0 +1,166 @@ +package main + +import ( + "bytes" + "fmt" + "math" + "os" + + "github.com/wcharczuk/go-chart/v2" + "gonum.org/v1/gonum/mat" +) + +// создание равномерной сети +func makeNet(a, b float64, n int) []float64 { + res := make([]float64, n+1) + for i := 0; i <= n; i++ { + res[i] = a + (b-a)/float64(n)*float64(i) + } + return res +} + +// уточнение по Ричардсону +func richardson(firstNet, secNet mat.VecDense) mat.VecDense { + n, _ := secNet.Dims() + delta := mat.NewVecDense(n+1, nil) + for i := 0; i < n; i += 2 { + delta.SetVec(i, (secNet.AtVec(i)-firstNet.AtVec(i/2))/3.0) + } + for i := 1; i < n; i += 2 { + delta.SetVec(i, (delta.AtVec(i-1)+delta.AtVec(i+1))/2.0) + } + res := mat.NewVecDense(n, nil) + res.CopyVec(delta) + return *res +} + +// создание трехдиагональной матрицы и решение САУ +func solveSae(p, q, r, f func(float64) float64, a, b float64, n int, typeF int, alpha1, alpha2, alpha, beta1, beta2, beta float64) ([]float64, mat.VecDense) { + x := makeNet(a, b, n) + h := (b - a) / float64(n) + rh := mat.NewVecDense(n+1, nil) + A := mat.NewDense(n+1, n+1, nil) + for i := 1; i < n; i++ { + Ai := -p(x[i]) - q(x[i])*h/2.0 + Ci := -p(x[i]) + q(x[i])*h/2.0 + Bi := Ai + Ci - h*h*r(x[i]) + Gi := h * h * f(x[i]) + if typeF == 2 { + Ai = -p(x[i]-h/2.0) - q(x[i])*h/2.0 + Ci = -p(x[i]+h/2.0) + q(x[i])*h/2.0 + Bi = Ai + Ci - h*h*r(x[i]) + Gi = h * h * f(x[i]) + } + A.Set(i, i-1, Ai) + A.Set(i, i, -Bi) + A.Set(i, i+1, Ci) + rh.SetVec(i, Gi) + } + A.Set(0, 0, -h*alpha1-alpha2) + A.Set(0, 1, alpha2) + A.Set(n, n-1, beta2) + A.Set(n, n, -h*beta1-beta2) + rh.SetVec(0, -h*alpha) + rh.SetVec(n, -h*beta) + + res := mat.NewVecDense(n+1, nil) + res.SolveVec(A, rh) + resArray := make([]float64, n+1) + for i := 0; i <= n; i++ { + resArray[i] = res.AtVec(i) + } + return x, *res +} + +// создание графиков по значениям +func drowGraphic(x, fx [][]float64, n []int, name string) { + dimN := len(n) + ts := []chart.Series{} + for i := 0; i < dimN; i++ { + curTs := chart.ContinuousSeries{ + Name: "N = " + fmt.Sprint(n[i]), + XValues: x[i], + YValues: fx[i], + } + ts = append(ts, curTs) + } + graph := chart.Chart{ + Background: chart.Style{ + Padding: chart.Box{ + Top: 20, + Left: 110, + Right: 20, + }, + }, + YAxis: chart.YAxis{ + ValueFormatter: func(v interface{}) string { + if vf, isFloat := v.(float64); isFloat { + return fmt.Sprintf("%0.6f", vf) + } + return "" + }, + }, + Series: ts, + } + + graph.Elements = []chart.Renderable{ + chart.LegendLeft(&graph), + } + + buffer := bytes.NewBuffer([]byte{}) + err := graph.Render(chart.PNG, buffer) + if err != nil { + fmt.Println(err) + } + + fo, err := os.Create(name + ".png") + if err != nil { + panic(err) + } + + if _, err := fo.Write(buffer.Bytes()); err != nil { + panic(err) + } +} + +// преобразование вектора в массив +func vecToArr(x mat.VecDense) []float64 { + n, _ := x.Dims() + res := make([]float64, n) + for i := 0; i < n; i++ { + res[i] = x.AtVec(i) + } + return res +} + +// нахождение решения дифференциального уравнения с заданной точностью +func solveTask(p, q, r, f func(float64) float64, a, b float64, typeF int, eps, alpha1, alpha2, alpha, beta1, beta2, beta float64) (A, B, C [][]float64, d []int) { + n1, n2 := 5, 10 + _, net1 := solveSae(p, q, r, f, a, b, n1, typeF, alpha1, alpha2, alpha, beta1, beta2, beta) + x2, net2 := solveSae(p, q, r, f, a, b, n2, typeF, alpha1, alpha2, alpha, beta1, beta2, beta) + delta := richardson(net1, net2) + + net2.AddVec(&net2, &delta) + x_dots := [][]float64{x2} + net_dots := [][]float64{vecToArr(net2)} + delta_dots := [][]float64{vecToArr(delta)} + n_dots := []int{n2} + norm := mat.Norm(&delta, math.Inf(1)) + fmt.Println("Epsilon is:", eps) + fmt.Println("Norm at N =", n2, "is", norm) + for norm > eps { + n2 *= 2 + net1 = *mat.VecDenseCopyOf(&net2) + x2, net2 = solveSae(p, q, r, f, a, b, n2, typeF, alpha1, alpha2, alpha, beta1, beta2, beta) + delta = richardson(net1, net2) + net2.AddVec(&net2, &delta) + + x_dots = append(x_dots, x2) + net_dots = append(net_dots, vecToArr(net2)) + delta_dots = append(delta_dots, vecToArr(delta)) + n_dots = append(n_dots, n2) + norm = mat.Norm(&delta, math.Inf(1)) + fmt.Println("Norm at N =", n2, "is", norm) + } + return x_dots, net_dots, delta_dots, n_dots +} diff --git a/task7/ritz.go b/task7/ritz.go new file mode 100644 index 0000000..c02af79 --- /dev/null +++ b/task7/ritz.go @@ -0,0 +1,143 @@ +package main + +import ( + "gonum.org/v1/gonum/diff/fd" + "gonum.org/v1/gonum/integrate" + "gonum.org/v1/gonum/mat" +) + +func integrateS(f func(float64) float64) float64 { + n := 1000 + a := -1 + b := 1 + x := make([]float64, n) + fx := make([]float64, n) + for i := 0; i < n; i++ { + x[i] = float64(a) + float64(b-a)/float64(n)*float64(i) + fx[i] = f(x[i]) + } + return integrate.Simpsons(x, fx) +} + +func bilineralForm(y, z, p, r func(float64) float64, typeF int, alpha1, alpha2, beta1, beta2 float64) float64 { + Ql, Qr := 0.0, 0.0 + if typeF == 1 { + Ql = alpha1 / alpha2 * p(-1.0) * y(-1.0) * z(-1.0) + } else if typeF == 2 { + Qr = beta1 / beta2 * p(1.0) * y(1.0) * z(1.0) + } else if typeF == 3 { + Ql = alpha1 / alpha2 * p(-1.0) * y(-1.0) * z(-1.0) + Qr = beta1 / beta2 * p(1.0) * y(1.0) * z(1.0) + } + f := func(x float64) float64 { + return p(x)*fd.Derivative(y, x, nil)*fd.Derivative(z, x, nil) + r(x)*y(x)*z(x) + } + return integrateS(f) + Ql + Qr +} + +func scalarMul(f, g func(float64) float64) float64 { + f0 := func(x float64) float64 { + return f(x) * g(x) + } + return integrateS(f0) +} + +func getC(n int, w []Funct, p, r, f func(float64) float64, typeF int, alpha1, alpha2, beta1, beta2 float64) *mat.VecDense { + A := mat.NewDense(n, n, nil) + F := mat.NewVecDense(n, nil) + for i := 0; i < n; i++ { + for j := 0; j < n; j++ { + A.Set(i, j, bilineralForm(w[i].f, w[j].f, p, r, typeF, alpha1, alpha2, beta1, beta2)) + } + F.SetVec(i, scalarMul(f, w[i].f)) + } + res := mat.NewVecDense(n, nil) + res.SolveVec(A, F) + return res +} + +type Funct struct { + f func(x float64) float64 +} + +func (f Funct) Add(g Funct) Funct { + return Funct{func(x float64) float64 { + return f.f(x) + g.f(x) + }} +} + +func (f Funct) Mul(g Funct) Funct { + return Funct{func(x float64) float64 { + return f.f(x) * g.f(x) + }} +} + +func getYn(n int, c mat.VecDense, w []Funct) Funct { + res := Funct{func(x float64) float64 { + return 0.0 + }} + for i := 0; i < n; i++ { + f := Funct{func(float64) float64 { + return c.AtVec(i) + }} + res = res.Add(Funct{func(x float64) float64 { + return f.f(x) * w[i].f(x) + }}) + } + return res +} + +func getP(k, n int) func(x float64) float64 { + if n == 0 { + p := func(float64) float64 { + return 1.0 + } + return p + } else if n == 1 { + p := func(x float64) float64 { + return float64(k+1.0) * x + } + return p + } + p := func(x float64) float64 { + return float64((n+k)*(2*n+2*k-1))*x*getP(k, n-1)(x)/float64((n+2*k)*(n)) - + float64((n+k)*(n+k-1))*getP(k, n-2)(x)/float64((n+2*k)*(n)) + } + return p +} + +func getWs(n int) []Funct { + res := make([]Funct, n) + res[0] = Funct{func(float64) float64 { + return 1.0 + }} + res[1] = Funct{func(x float64) float64 { + return x + }} + for i := 0; i < n-2; i++ { + res[i+2] = Funct{func(x float64) float64 { + return (1.0 - x*x) * getP(1, i)(x) + }} + } + return res +} + +func solveRitz(p, r, f func(float64) float64, typeF int, alpha1, alpha2, beta1, beta2 float64) { + x := make([][]float64, 5) + fx := make([][]float64, 5) + ns := make([]int, 5) + ind := 0 + for n := 4; n < 13; n += 2 { + ws := getWs(n) + c := getC(n, ws, p, r, f, typeF, alpha1, alpha2, beta1, beta2) + res := getYn(n, *c, ws) + x[ind] = makeNet(-1, 1, n) + fx[ind] = make([]float64, n+1) + for i, el := range x[ind] { + fx[ind][i] = res.f(el) + } + ns[ind] = n + ind += 1 + } + drowGraphic(x, fx, ns, "8-ritz") +}