Data commit

Task/Cholesky-decomposition/Go/cholesky-decomposition-1.go

@@ -0,0 +1,105 @@
+package main
+
+import (
+    "fmt"
+    "math"
+)
+
+// symmetric and lower use a packed representation that stores only
+// the lower triangle.
+
+type symmetric struct {
+    order int
+    ele   []float64
+}
+
+type lower struct {
+    order int
+    ele   []float64
+}
+
+// symmetric.print prints a square matrix from the packed representation,
+// printing the upper triange as a transpose of the lower.
+func (s *symmetric) print() {
+    const eleFmt = "%10.5f "
+    row, diag := 1, 0
+    for i, e := range s.ele {
+        fmt.Printf(eleFmt, e)
+        if i == diag {
+            for j, col := diag+row, row; col < s.order; j += col {
+                fmt.Printf(eleFmt, s.ele[j])
+                col++
+            }
+            fmt.Println()
+            row++
+            diag += row
+        }
+    }
+}
+
+// lower.print prints a square matrix from the packed representation,
+// printing the upper triangle as all zeros.
+func (l *lower) print() {
+    const eleFmt = "%10.5f "
+    row, diag := 1, 0
+    for i, e := range l.ele {
+        fmt.Printf(eleFmt, e)
+        if i == diag {
+            for j := row; j < l.order; j++ {
+                fmt.Printf(eleFmt, 0.)
+            }
+            fmt.Println()
+            row++
+            diag += row
+        }
+    }
+}
+
+// choleskyLower returns the cholesky decomposition of a symmetric real
+// matrix.  The matrix must be positive definite but this is not checked.
+func (a *symmetric) choleskyLower() *lower {
+    l := &lower{a.order, make([]float64, len(a.ele))}
+    row, col := 1, 1
+    dr := 0 // index of diagonal element at end of row
+    dc := 0 // index of diagonal element at top of column
+    for i, e := range a.ele {
+        if i < dr {
+            d := (e - l.ele[i]) / l.ele[dc]
+            l.ele[i] = d
+            ci, cx := col, dc
+            for j := i + 1; j <= dr; j++ {
+                cx += ci
+                ci++
+                l.ele[j] += d * l.ele[cx]
+            }
+            col++
+            dc += col
+        } else {
+            l.ele[i] = math.Sqrt(e - l.ele[i])
+            row++
+            dr += row
+            col = 1
+            dc = 0
+        }
+    }
+    return l
+}
+
+func main() {
+    demo(&symmetric{3, []float64{
+        25,
+        15, 18,
+        -5, 0, 11}})
+    demo(&symmetric{4, []float64{
+        18,
+        22, 70,
+        54, 86, 174,
+        42, 62, 134, 106}})
+}
+
+func demo(a *symmetric) {
+    fmt.Println("A:")
+    a.print()
+    fmt.Println("L:")
+    a.choleskyLower().print()
+}

Task/Cholesky-decomposition/Go/cholesky-decomposition-2.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+    "fmt"
+    "math/cmplx"
+)
+
+type matrix struct {
+    stride int
+    ele    []complex128
+}
+
+func like(a *matrix) *matrix {
+    return &matrix{a.stride, make([]complex128, len(a.ele))}
+}
+
+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("%7.2f ", m.ele[e:e+m.stride])
+        fmt.Println()
+    }
+}
+
+func (a *matrix) choleskyDecomp() *matrix {
+    l := like(a)
+    // Cholesky-Banachiewicz algorithm
+    for r, rxc0 := 0, 0; r < a.stride; r++ {
+        // calculate elements along row, up to diagonal
+        x := rxc0
+        for c, cxc0 := 0, 0; c < r; c++ {
+            sum := a.ele[x]
+            for k := 0; k < c; k++ {
+                sum -= l.ele[rxc0+k] * cmplx.Conj(l.ele[cxc0+k])
+            }
+            l.ele[x] = sum / l.ele[cxc0+c]
+            x++
+            cxc0 += a.stride
+        }
+        // calcualate diagonal element
+        sum := a.ele[x]
+        for k := 0; k < r; k++ {
+            sum -= l.ele[rxc0+k] * cmplx.Conj(l.ele[rxc0+k])
+        }
+        l.ele[x] = cmplx.Sqrt(sum)
+        rxc0 += a.stride
+    }
+    return l
+}
+
+func main() {
+    demo("A:", &matrix{3, []complex128{
+        25, 15, -5,
+        15, 18, 0,
+        -5, 0, 11,
+    }})
+    demo("A:", &matrix{4, []complex128{
+        18, 22, 54, 42,
+        22, 70, 86, 62,
+        54, 86, 174, 134,
+        42, 62, 134, 106,
+    }})
+    // one more example, from the Numpy manual, with a non-real
+    demo("A:", &matrix{2, []complex128{
+        1, -2i,
+        2i, 5,
+    }})
+}
+
+func demo(heading string, a *matrix) {
+    a.print(heading)
+    a.choleskyDecomp().print("Cholesky factor L:")
+}

Task/Cholesky-decomposition/Go/cholesky-decomposition-3.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+    "fmt"
+
+    "gonum.org/v1/gonum/mat"
+)
+
+func cholesky(order int, elements []float64) fmt.Formatter {
+    var c mat.Cholesky
+    c.Factorize(mat.NewSymDense(order, elements))
+    return mat.Formatted(c.LTo(nil))
+}
+
+func main() {
+    fmt.Println(cholesky(3, []float64{
+        25, 15, -5,
+        15, 18, 0,
+        -5, 0, 11,
+    }))
+    fmt.Printf("\n%.5f\n", cholesky(4, []float64{
+        18, 22, 54, 42,
+        22, 70, 86, 62,
+        54, 86, 174, 134,
+        42, 62, 134, 106,
+    }))
+}

Task/Cholesky-decomposition/Go/cholesky-decomposition-4.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+    "fmt"
+
+    mat "github.com/skelterjohn/go.matrix"
+)
+
+func main() {
+    demo(mat.MakeDenseMatrix([]float64{
+        25, 15, -5,
+        15, 18, 0,
+        -5, 0, 11,
+    }, 3, 3))
+    demo(mat.MakeDenseMatrix([]float64{
+        18, 22, 54, 42,
+        22, 70, 86, 62,
+        54, 86, 174, 134,
+        42, 62, 134, 106,
+    }, 4, 4))
+}
+
+func demo(m *mat.DenseMatrix) {
+    fmt.Println("A:")
+    fmt.Println(m)
+    l, err := m.Cholesky()
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    fmt.Println("L:")
+    fmt.Println(l)
+}