Covariance6x6

SUMMARY

A 6 × 6 covariance matrix.

from telekinesis import datatypes
covariance = datatypes.Covariance6x6(
    [
        [1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        [0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
        [0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
        [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
        [0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
        [0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
    ]
)

API Reference

Complete API documentation for Covariance6x6, including parameters, attributes, and methods.

View Reference →

Parameters

Parameter	Type	Default	Description
data	np.ndarray | list | tuple	Required	Symmetric positive-semidefinite covariance matrix with shape (6, 6).

Raises

Exception	Condition
TypeError	data can't be converted to float32 (e.g. non-numeric elements)
ValueError	data is not rank-2, or its shape isn't (6, 6)
ValueError	data contains a non-finite value (NaN/Inf)
ValueError	data isn't symmetric within covariance_atol (max |C - Cᵗ| > covariance_atol)
ValueError	data isn't positive semi-definite (smallest eigenvalue < -covariance_atol)

Attributes

Attribute	Type	Description
data	np.ndarray	Defensive copy of the underlying (6, 6) float32 matrix. Assigning a new value re-validates it (shape, finiteness, symmetry, PSD) the same way as construction.
shape	tuple[int, ...]	Always (6, 6).
ndim	int	Always 2.
dtype	np.dtype	Always float32.
size	int	Always 36.
covariance_atol	float	Class-level absolute tolerance (1e-6) used when checking symmetry and positive semi-definiteness.

Methods

Method	Type	Description
Covariance6x6.coerce(value)	Covariance6x6	Converts array-like data into a Covariance6x6, running the same symmetry and positive-semi-definiteness checks as the constructor. Accepts a np.ndarray, list, or tuple. If value is already a Covariance6x6, it is returned unchanged.
to_numpy(copy=True)	np.ndarray	Returns the matrix as a plain array. With the default copy=True you get an independent copy; pass copy=False to get a direct reference to the internal array instead, so mutating it also mutates the Covariance6x6.
copy()	Covariance6x6	Returns a new, independent Covariance6x6 with the same data.

Operators

Operation	Behavior
c == other	True only if other is also a Covariance6x6 with element-equal data. False for anything else.
len(c)	Always 6 (length of the first axis).
np.asarray(c)	Returns a copy of data as an np.ndarray; NumPy functions accept a Covariance6x6 directly.

Visualization

import rerun as rr

# Your code block
# ....

rr.init("covariance6x6_example", spawn=True)
datatypes.visualize(covariance, entity_path="/covariance", label="Covariance6x6")

Example

"""Demonstrates the Telekinesis Covariance6x6 datatype."""

import time

import numpy as np
import rerun as rr
from loguru import logger

from telekinesis import datatypes

def covariance6x6_example():
    """Demonstrate creation, inspection, operations, visualization, and serialization."""

    # ======================= Create ============================================
    matrix = np.diag([1.0, 2.0, 3.0, 0.5, 0.5, 0.5]).astype(np.float32)
    covariance = datatypes.Covariance6x6(matrix)
    logger.info(f"Created Covariance6x6:\n{covariance.data}")

    # ======================= Inspect ===========================================
    logger.info(f"data=\n{covariance.data}")
    logger.info(f"shape={covariance.shape}")
    logger.info(f"ndim={covariance.ndim}")
    logger.info(f"dtype={covariance.dtype}")
    logger.info(f"size={covariance.size}")
    logger.info(f"covariance_atol={covariance.covariance_atol}")

    # ======================= Operations =========================================
    covariance_copy = covariance.copy()
    logger.info(f"Copied Covariance6x6:\n{covariance_copy.data}")

    covariance.data = np.eye(6, dtype=np.float32) * 2.0
    logger.info(f"Updated Covariance6x6:\n{covariance.data}")

    covariance_numpy = covariance.to_numpy(copy=True)
    logger.info(f"NumPy Covariance6x6:\n{covariance_numpy}")

    numpy_array = np.asarray(covariance)
    logger.info(f"NumPy array via __array__:\n{numpy_array}")

    is_symmetric = np.allclose(covariance.data, covariance.data.T)
    eigenvalues = np.linalg.eigvalsh(covariance.data)
    variances = np.diag(covariance.data)

    logger.info(f"Is symmetric (np.allclose with transpose): {is_symmetric}")
    logger.info(f"Eigenvalues (np.linalg.eigvalsh): {eigenvalues}")
    logger.info(f"Per-axis variances (np.diag): {variances}")

    # ======================= Visualize =========================================
    rr.init("covariance6x6_example", spawn=True)
    datatypes.visualize(covariance_copy, entity_path="/covariance6x6/original")
    datatypes.visualize(covariance, entity_path="/covariance6x6/updated")

    # ======================= Serialize / Deserialize ===========================
    start = time.perf_counter()
    serialized = datatypes.serialize(covariance)
    serialization_ms = (time.perf_counter() - start) * 1000

    start = time.perf_counter()
    deserialized = datatypes.deserialize(serialized)["param_0"]
    deserialization_ms = (time.perf_counter() - start) * 1000

    logger.info(f"Deserialized Covariance6x6:\n{deserialized.data}")
    logger.info(f"Round-trip successful: {covariance == deserialized}")
    logger.info(f"Serialization time: {serialization_ms:.3f} ms")
    logger.info(f"Deserialization time: {deserialization_ms:.3f} ms")


if __name__ == "__main__":
    covariance6x6_example()