Data commit

Task/LU-decomposition/Go/lu-decomposition-1.go

@@ -0,0 +1,110 @@
+package main
+
+import "fmt"
+
+type matrix [][]float64
+
+func zero(n int) matrix {
+    r := make([][]float64, n)
+    a := make([]float64, n*n)
+    for i := range r {
+        r[i] = a[n*i : n*(i+1)]
+    }
+    return r
+}
+
+func eye(n int) matrix {
+    r := zero(n)
+    for i := range r {
+        r[i][i] = 1
+    }
+    return r
+}
+
+func (m matrix) print(label string) {
+    if label > "" {
+        fmt.Printf("%s:\n", label)
+    }
+    for _, r := range m {
+        for _, e := range r {
+            fmt.Printf(" %9.5f", e)
+        }
+        fmt.Println()
+    }
+}
+
+func (a matrix) pivotize() matrix {
+    p := eye(len(a))
+    for j, r := range a {
+        max := r[j]
+        row := j
+        for i := j; i < len(a); i++ {
+            if a[i][j] > max {
+                max = a[i][j]
+                row = i
+            }
+        }
+        if j != row {
+            // swap rows
+            p[j], p[row] = p[row], p[j]
+        }
+    }
+    return p
+}
+
+func (m1 matrix) mul(m2 matrix) matrix {
+    r := zero(len(m1))
+    for i, r1 := range m1 {
+        for j := range m2 {
+            for k := range m1 {
+                r[i][j] += r1[k] * m2[k][j]
+            }
+        }
+    }
+    return r
+}
+
+func (a matrix) lu() (l, u, p matrix) {
+    l = zero(len(a))
+    u = zero(len(a))
+    p = a.pivotize()
+    a = p.mul(a)
+    for j := range a {
+        l[j][j] = 1
+        for i := 0; i <= j; i++ {
+            sum := 0.
+            for k := 0; k < i; k++ {
+                sum += u[k][j] * l[i][k]
+            }
+            u[i][j] = a[i][j] - sum
+        }
+        for i := j; i < len(a); i++ {
+            sum := 0.
+            for k := 0; k < j; k++ {
+                sum += u[k][j] * l[i][k]
+            }
+            l[i][j] = (a[i][j] - sum) / u[j][j]
+        }
+    }
+    return
+}
+
+func main() {
+    showLU(matrix{
+        {1, 3, 5},
+        {2, 4, 7},
+        {1, 1, 0}})
+    showLU(matrix{
+        {11, 9, 24, 2},
+        {1, 5, 2, 6},
+        {3, 17, 18, 1},
+        {2, 5, 7, 1}})
+}
+
+func showLU(a matrix) {
+    a.print("\na")
+    l, u, p := a.lu()
+    l.print("l")
+    u.print("u")
+    p.print("p")
+}

Task/LU-decomposition/Go/lu-decomposition-2.go

@@ -0,0 +1,123 @@
+package main
+
+import "fmt"
+
+type matrix struct {
+    stride int
+    ele    []float64
+}
+
+func (m *matrix) print(heading string) {
+    if heading > "" {
+        fmt.Print("\n", heading, "\n")
+    }
+    for e := 0; e < len(m.ele); e += m.stride {
+        fmt.Printf("%8.5f ", m.ele[e:e+m.stride])
+        fmt.Println()
+    }
+}
+
+func (m1 *matrix) mul(m2 *matrix) (m3 *matrix, ok bool) {
+    if m1.stride*m2.stride != len(m2.ele) {
+        return nil, false
+    }
+    m3 = &matrix{m2.stride, make([]float64, (len(m1.ele)/m1.stride)*m2.stride)}
+    for m1c0, m3x := 0, 0; m1c0 < len(m1.ele); m1c0 += m1.stride {
+        for m2r0 := 0; m2r0 < m2.stride; m2r0++ {
+            for m1x, m2x := m1c0, m2r0; m2x < len(m2.ele); m2x += m2.stride {
+                m3.ele[m3x] += m1.ele[m1x] * m2.ele[m2x]
+                m1x++
+            }
+            m3x++
+        }
+    }
+    return m3, true
+}
+
+func zero(rows, cols int) *matrix {
+    return &matrix{cols, make([]float64, rows*cols)}
+}
+
+func eye(n int) *matrix {
+    m := zero(n, n)
+    for ix := 0; ix < len(m.ele); ix += n + 1 {
+        m.ele[ix] = 1
+    }
+    return m
+}
+
+func (a *matrix) pivotize() *matrix {
+    pv := make([]int, a.stride)
+    for i := range pv {
+        pv[i] = i
+    }
+    for j, dx := 0, 0; j < a.stride; j++ {
+        row := j
+        max := a.ele[dx]
+        for i, ixcj := j, dx; i < a.stride; i++ {
+            if a.ele[ixcj] > max {
+                max = a.ele[ixcj]
+                row = i
+            }
+            ixcj += a.stride
+        }
+        if j != row {
+            pv[row], pv[j] = pv[j], pv[row]
+        }
+        dx += a.stride + 1
+    }
+    p := zero(a.stride, a.stride)
+    for r, c := range pv {
+        p.ele[r*a.stride+c] = 1
+    }
+    return p
+}
+
+func (a *matrix) lu() (l, u, p *matrix) {
+    l = zero(a.stride, a.stride)
+    u = zero(a.stride, a.stride)
+    p = a.pivotize()
+    a, _ = p.mul(a)
+    for j, jxc0 := 0, 0; j < a.stride; j++ {
+        l.ele[jxc0+j] = 1
+        for i, ixc0 := 0, 0; ixc0 <= jxc0; i++ {
+            sum := 0.
+            for k, kxcj := 0, j; k < i; k++ {
+                sum += u.ele[kxcj] * l.ele[ixc0+k]
+                kxcj += a.stride
+            }
+            u.ele[ixc0+j] = a.ele[ixc0+j] - sum
+            ixc0 += a.stride
+        }
+        for ixc0 := jxc0; ixc0 < len(a.ele); ixc0 += a.stride {
+            sum := 0.
+            for k, kxcj := 0, j; k < j; k++ {
+                sum += u.ele[kxcj] * l.ele[ixc0+k]
+                kxcj += a.stride
+            }
+            l.ele[ixc0+j] = (a.ele[ixc0+j] - sum) / u.ele[jxc0+j]
+        }
+        jxc0 += a.stride
+    }
+    return
+}
+
+func main() {
+    showLU(&matrix{3, []float64{
+        1, 3, 5,
+        2, 4, 7,
+        1, 1, 0}})
+    showLU(&matrix{4, []float64{
+        11, 9, 24, 2,
+        1, 5, 2, 6,
+        3, 17, 18, 1,
+        2, 5, 7, 1}})
+}
+
+func showLU(a *matrix) {
+    a.print("\na")
+    l, u, p := a.lu()
+    l.print("l")
+    u.print("u")
+    p.print("p")
+}

Task/LU-decomposition/Go/lu-decomposition-3.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+    "fmt"
+
+    "gonum.org/v1/gonum/mat"
+)
+
+func main() {
+    showLU(mat.NewDense(3, 3, []float64{
+        1, 3, 5,
+        2, 4, 7,
+        1, 1, 0,
+    }))
+    fmt.Println()
+    showLU(mat.NewDense(4, 4, []float64{
+        11, 9, 24, 2,
+        1, 5, 2, 6,
+        3, 17, 18, 1,
+        2, 5, 7, 1,
+    }))
+}
+
+func showLU(a *mat.Dense) {
+    fmt.Printf("a: %v\n\n", mat.Formatted(a, mat.Prefix("   ")))
+    var lu mat.LU
+    lu.Factorize(a)
+    l := lu.LTo(nil)
+    u := lu.UTo(nil)
+    fmt.Printf("l: %.5f\n\n", mat.Formatted(l, mat.Prefix("   ")))
+    fmt.Printf("u: %.5f\n\n", mat.Formatted(u, mat.Prefix("   ")))
+    fmt.Println("p:", lu.Pivot(nil))
+}

Task/LU-decomposition/Go/lu-decomposition-4.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+    "fmt"
+
+    mat "github.com/skelterjohn/go.matrix"
+)
+
+func main() {
+    showLU(mat.MakeDenseMatrixStacked([][]float64{
+        {1, 3, 5},
+        {2, 4, 7},
+        {1, 1, 0}}))
+    showLU(mat.MakeDenseMatrixStacked([][]float64{
+        {11, 9, 24, 2},
+        {1, 5, 2, 6},
+        {3, 17, 18, 1},
+        {2, 5, 7, 1}}))
+}
+
+func showLU(a *mat.DenseMatrix) {
+    fmt.Printf("\na:\n%v\n", a)
+    l, u, p := a.LU()
+    fmt.Printf("l:\n%v\n", l)
+    fmt.Printf("u:\n%v\n", u)
+    fmt.Printf("p:\n%v\n", p)
+}