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

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 mat.QR in 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:
  - mat.QR

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:0d16a38ca52284141272f05a5c0d711a0286ef29e0be0f412b40678652376f61","contract":["qr.Factorize computes the QR decomposition of a matrix where Q is orthonormal and R is upper triangular","qr.QTo and qr.RTo reconstruct the original matrix when multiplied as Q * R","qr.SolveTo solves the linear system Ax = b for x","qr.Dims returns the row and column dimensions of the factorized matrix","qr.Factorize panics when the number of rows is less than the number of columns"],"goal":"verify mat.QR in pkg:golang/gonum.org/v1/gonum@v0.17.0","kind":"HOW","packages":["pkg:golang/gonum.org/v1/gonum@v0.17.0"],"schemaVersion":1,"symbols":["mat.QR"]},"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":["mat.QR"],"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"
	"log"

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

func main() {
	// Define a 4x3 matrix A
	a := mat.NewDense(4, 3, []float64{
		12, -51, 4,
		6, 167, -68,
		-4, 24, -41,
		-1, 1, 0,
	})

	// Factorize A into Q and R (A = Q * R)
	var qr mat.QR
	qr.Factorize(a)

	r, c := qr.Dims()
	fmt.Printf("Factorized matrix dimensions: %d x %d\n", r, c)

	// Extract Q (4x4 orthonormal matrix)
	var q mat.Dense
	qr.QTo(&q)
	fmt.Println("Matrix Q:")
	fmt.Printf("%.4f\n", mat.Formatted(&q))

	// Extract R (4x3 upper triangular/trapezoidal matrix)
	var rMat mat.Dense
	qr.RTo(&rMat)
	fmt.Println("Matrix R:")
	fmt.Printf("%.4f\n", mat.Formatted(&rMat))

	// Solve linear system Ax = b using QR decomposition
	b := mat.NewDense(4, 1, []float64{1, 2, 3, 4})
	var x mat.Dense
	if err := qr.SolveTo(&x, false, b); err != nil {
		log.Fatalf("QR solve failed: %v", err)
	}
	fmt.Println("Solution vector x:")
	fmt.Printf("%.4f\n", mat.Formatted(&x))
}

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

package main

import (
	"fmt"
	"math"
	"os"

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

func main() {
	// Assertion 1: qr.Factorize computes the QR decomposition of a matrix where Q is orthonormal and R is upper triangular
	a := mat.NewDense(4, 3, []float64{
		12, -51, 4,
		6, 167, -68,
		-4, 24, -41,
		-1, 1, 0,
	})
	var qr mat.QR
	qr.Factorize(a)

	var q mat.Dense
	qr.QTo(&q)

	// Check Q is 4x4 orthonormal: Q^T * Q = I
	var qTq mat.Dense
	qTq.Mul(q.T(), &q)
	for i := 0; i < 4; i++ {
		for j := 0; j < 4; j++ {
			expected := 0.0
			if i == j {
				expected = 1.0
			}
			if math.Abs(qTq.At(i, j)-expected) > 1e-10 {
				fmt.Fprintf(os.Stderr, "FAIL: Q is not orthonormal at (%d, %d): got %f, want %f\n", i, j, qTq.At(i, j), expected)
				os.Exit(1)
			}
		}
	}

	// Check R is 4x3 upper triangular (entries below diagonal are 0)
	var r mat.Dense
	qr.RTo(&r)
	for i := 0; i < 4; i++ {
		for j := 0; j < 3; j++ {
			if i > j && math.Abs(r.At(i, j)) > 1e-10 {
				fmt.Fprintf(os.Stderr, "FAIL: R is not upper triangular at (%d, %d): got %f\n", i, j, r.At(i, j))
				os.Exit(1)
			}
		}
	}

	// Assertion 2: qr.QTo and qr.RTo reconstruct the original matrix when multiplied as Q * R
	var reconstructed mat.Dense
	reconstructed.Mul(&q, &r)
	for i := 0; i < 4; i++ {
		for j := 0; j < 3; j++ {
			if math.Abs(reconstructed.At(i, j)-a.At(i, j)) > 1e-10 {
				fmt.Fprintf(os.Stderr, "FAIL: Reconstructed matrix mismatch at (%d, %d): got %f, want %f\n",
					i, j, reconstructed.At(i, j), a.At(i, j))
				os.Exit(1)
			}
		}
	}

	// Assertion 3: qr.SolveTo solves the linear system Ax = b for x
	aSquare := mat.NewDense(3, 3, []float64{
		1, 2, 0,
		0, 1, 1,
		1, 0, 1,
	})
	var qrSquare mat.QR
	qrSquare.Factorize(aSquare)
	b := mat.NewDense(3, 1, []float64{5, 5, 4})
	var x mat.Dense
	if err := qrSquare.SolveTo(&x, false, b); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: qr.SolveTo returned error: %v\n", err)
		os.Exit(1)
	}

	var ax mat.Dense
	ax.Mul(aSquare, &x)
	for i := 0; i < 3; i++ {
		if math.Abs(ax.At(i, 0)-b.At(i, 0)) > 1e-10 {
			fmt.Fprintf(os.Stderr, "FAIL: Ax != b at row %d: got %f, want %f\n", i, ax.At(i, 0), b.At(i, 0))
			os.Exit(1)
		}
	}

	// Assertion 4: qr.Dims returns the row and column dimensions of the factorized matrix
	rows, cols := qr.Dims()
	if rows != 4 || cols != 3 {
		fmt.Fprintf(os.Stderr, "FAIL: qr.Dims returned (%d, %d), want (4, 3)\n", rows, cols)
		os.Exit(1)
	}

	// Assertion 5: qr.Factorize panics when the number of rows is less than the number of columns
	dimPanicked := false
	func() {
		defer func() {
			if r := recover(); r != nil {
				dimPanicked = true
			}
		}()
		wideMatrix := mat.NewDense(2, 3, []float64{
			1, 2, 3,
			4, 5, 6,
		})
		var qrWide mat.QR
		qrWide.Factorize(wideMatrix)
	}()
	if !dimPanicked {
		fmt.Fprintf(os.Stderr, "FAIL: qr.Factorize did not panic when m < n\n")
		os.Exit(1)
	}

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