gonum.org/v1/gonum v0.17.0: mat.Cholesky

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:golang/gonum.org/v1/gonum@v0.17.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/gonum.org/v1/gonum@v0.17.0
Demonstrate these symbols/APIs:
  - gonum.org/v1/gonum/mat.Cholesky

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:993a775df757adfe543006a43fa0b91f4388911ed626e1af557fdbb08ff3d7bd","contract":["mat.Cholesky.Factorize calculates the Cholesky decomposition of a symmetric positive definite matrix and returns true","mat.Cholesky.Factorize returns false when given a non-positive-definite matrix","mat.Cholesky.Det computes the determinant of the factorized matrix","mat.Cholesky.LTo extracts the lower triangular Cholesky factor satisfying A = L * L^T","mat.Cholesky.SolveTo solves the linear system A * X = B for a factorized matrix","mat.Cholesky.InverseTo computes the symmetric inverse of the factorized matrix","mat.Cholesky panics when calling Det on an uninitialized factorization"],"goal":"verify pkg:golang/gonum.org/v1/gonum@v0.17.0","kind":"HOW","packages":["pkg:golang/gonum.org/v1/gonum@v0.17.0"],"schemaVersion":1,"symbols":["gonum.org/v1/gonum/mat.Cholesky"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/gonum.org/v1/gonum@v0.17.0"],"schemaVersion":1,"subject":"pkg:golang/gonum.org/v1/gonum@v0.17.0","symbols":["gonum.org/v1/gonum/mat.Cholesky"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require gonum.org/v1/gonum v0.17.0

gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=

package main

import (
	"fmt"

	"gonum.org/v1/gonum/mat"
)

func main() {
	// Define a 2x2 symmetric positive-definite matrix A = [4, 2; 2, 5]
	a := mat.NewSymDense(2, []float64{
		4, 2,
		2, 5,
	})

	// Compute Cholesky factorization
	var chol mat.Cholesky
	if !chol.Factorize(a) {
		panic("matrix is not positive definite")
	}

	fmt.Printf("Determinant: %.4f\n", chol.Det())

	// Solve A * x = b for b = [6; 7]
	b := mat.NewDense(2, 1, []float64{6, 7})
	var x mat.Dense
	if err := chol.SolveTo(&x, b); err != nil {
		panic(err)
	}
	fmt.Printf("Solution: [%.4f, %.4f]\n", x.At(0, 0), x.At(1, 0))
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/gonum.org/v1/gonum@v0.17.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/gonum.org/v1/gonum@v0.17.0"
  ],
  "symbols": [
    "gonum.org/v1/gonum/mat.Cholesky"
  ]
}

package main

import (
	"fmt"
	"math"
	"os"

	"gonum.org/v1/gonum/mat"
)

func main() {
	// Define a 2x2 symmetric positive-definite matrix A = [4, 2; 2, 5]
	a := mat.NewSymDense(2, []float64{
		4, 2,
		2, 5,
	})

	// Assertion 1: mat.Cholesky.Factorize calculates the Cholesky decomposition of a symmetric positive definite matrix and returns true
	var chol mat.Cholesky
	ok := chol.Factorize(a)
	if !ok {
		fmt.Fprintf(os.Stderr, "FAIL: Factorize failed on positive-definite matrix\n")
		os.Exit(1)
	}

	// Assertion 2: mat.Cholesky.Factorize returns false when given a non-positive-definite matrix
	aNpd := mat.NewSymDense(2, []float64{
		1, 2,
		2, 1,
	})
	var cholNpd mat.Cholesky
	if cholNpd.Factorize(aNpd) {
		fmt.Fprintf(os.Stderr, "FAIL: Factorize succeeded on non-positive-definite matrix\n")
		os.Exit(1)
	}

	// Assertion 3: mat.Cholesky.Det computes the determinant of the factorized matrix
	det := chol.Det()
	expectedDet := 16.0 // 4*5 - 2*2 = 16
	if math.Abs(det-expectedDet) > 1e-9 {
		fmt.Fprintf(os.Stderr, "FAIL: Det mismatch: got %f, want %f\n", det, expectedDet)
		os.Exit(1)
	}

	// Assertion 4: mat.Cholesky.LTo extracts the lower triangular Cholesky factor satisfying A = L * L^T
	var l mat.TriDense
	chol.LTo(&l)
	_, kind := l.Triangle()
	if kind != mat.Lower {
		fmt.Fprintf(os.Stderr, "FAIL: LTo did not return a lower triangular matrix\n")
		os.Exit(1)
	}
	var lProduct mat.Dense
	lProduct.Mul(&l, l.T())
	if !mat.EqualApprox(a, &lProduct, 1e-9) {
		fmt.Fprintf(os.Stderr, "FAIL: L * L^T does not match original matrix A\n")
		os.Exit(1)
	}

	// Assertion 5: mat.Cholesky.SolveTo solves the linear system A * X = B for a factorized matrix
	b := mat.NewDense(2, 1, []float64{6, 7})
	var x mat.Dense
	if err := chol.SolveTo(&x, b); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: SolveTo returned unexpected error: %v\n", err)
		os.Exit(1)
	}
	if math.Abs(x.At(0, 0)-1.0) > 1e-9 || math.Abs(x.At(1, 0)-1.0) > 1e-9 {
		fmt.Fprintf(os.Stderr, "FAIL: SolveTo solution mismatch: got [%f, %f], want [1.0, 1.0]\n", x.At(0, 0), x.At(1, 0))
		os.Exit(1)
	}

	// Assertion 6: mat.Cholesky.InverseTo computes the symmetric inverse of the factorized matrix
	var inv mat.SymDense
	if err := chol.InverseTo(&inv); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: InverseTo returned unexpected error: %v\n", err)
		os.Exit(1)
	}
	var ident mat.Dense
	ident.Mul(a, &inv)
	expectedIdent := mat.NewDense(2, 2, []float64{
		1, 0,
		0, 1,
	})
	if !mat.EqualApprox(&ident, expectedIdent, 1e-9) {
		fmt.Fprintf(os.Stderr, "FAIL: A * A^{-1} is not identity\n")
		os.Exit(1)
	}

	// Assertion 7: mat.Cholesky panics when calling Det on an uninitialized factorization
	detPanicked := false
	func() {
		defer func() {
			if r := recover(); r != nil {
				detPanicked = true
			}
		}()
		var uninit mat.Cholesky
		_ = uninit.Det()
	}()
	if !detPanicked {
		fmt.Fprintf(os.Stderr, "FAIL: Det did not panic on uninitialized Cholesky factorization\n")
		os.Exit(1)
	}

	fmt.Println("All gonum mat.Cholesky contract assertions passed.")
}