Add frame-tagged 6x6 matrix and semantic type aliases for vectors

CHANGELOG.md

@@ -6,10 +6,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [unreleased]
 
+## [0.7.1 - 2026-05-14]
+
 ### Added
 - New frame-tagged 3×3 matrix primitives in `affn::matrix3`: `FrameMatrix3<F, T>` for general matrices and `SymmetricFrameMatrix3<F, T>` for symmetry-preserving covariance-style blocks.
 - Rotation similarity helpers on the new matrix types: `rotated_by::<G>(&Rotation3)` for frame-changing `R · M · Rᵀ` transforms, with numerical re-symmetrization for `SymmetricFrameMatrix3`.
 - `Rotation3::apply_vec<F1, F2, U>` for rotating typed `Vector`/`Displacement` values while preserving units and retagging the output frame.
+- New frame-tagged 6×6 matrix primitives in `affn::matrix6`: `FrameMatrix6<F>` for general 6×6 matrices and `BlockDiagRotation6<F>` for block-diagonal `blockdiag(R, R)` frame-change transforms on `[position; velocity]` state vectors. Uses the instantaneous-rotation convention (time-derivative `Ṙ` ignored), which is correct for covariance transport and fixed-epoch STM frame changes.
+- Additional helpers on `FrameMatrix3<F>`: `from_diagonal`, matrix–matrix product `mat_mul`, transpose `transpose`, and frame-retag `retag`.
+- `Acceleration<F, U>` semantic type alias for `Vector<F, U>` where `U` is an acceleration unit, representing the second time-derivative of position. Available from `affn::cartesian`, the crate root, and `affn::prelude`.
+- `Force<F, U>` semantic type alias for `Vector<F, U>` where `U` is a force unit (e.g. `Newton`, `Kilonewton`), representing the physical cause of acceleration via Newton's second law. Available from `affn::cartesian`, the crate root, and `affn::prelude`.
 
 ### Changed
 - `Position<C, F, U>` now implements `PartialEq`, comparing both Cartesian coordinates and `center_params` so affine points only compare equal when they represent the same location relative to the same parameterized center state.

Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "affn"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2021"
 authors = ["VPRamon <vallespuigramon@gmail.com>"]
 description = "Affine geometry primitives: strongly-typed coordinate systems, reference frames, and centers for scientific computing."
@@ -21,8 +21,8 @@ serde = ["dep:serde", "qtty/serde"]
 astro = ["qtty/astro"]
 
 [dependencies]
-affn-derive = { version = "0.7.0", path = "affn-derive" }
-qtty = "0.7.1"
+affn-derive = { version = "0.7.1", path = "affn-derive" }
+qtty = "0.8"
 serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
 
 [dev-dependencies]

README.md

@@ -33,8 +33,8 @@ Add the dependency:
 
 ```toml
 [dependencies]
-affn = "0.7.0"
-qtty = "0.7.1"
+affn = "0.7.1"
+qtty = "0.8.1"
 ```
 
 Define a center + frame and do basic affine algebra:

affn-derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "affn-derive"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2021"
 authors = ["VPRamon <vallespuigramon@gmail.com>"]
 description = "Derive macros for affn: ReferenceFrame and ReferenceCenter"

affn-derive/src/center.rs

@@ -69,40 +69,61 @@ pub(crate) fn parse_center_attributes(input: &DeriveInput) -> syn::Result<Center
             )?;
 
             for meta in nested {
-                if let Meta::NameValue(nv) = meta {
-                    if nv.path.is_ident("name") {
-                        if let Expr::Lit(expr_lit) = &nv.value {
-                            if let Lit::Str(lit_str) = &expr_lit.lit {
-                                attrs.name = Some(lit_str.value());
-                                continue;
+                match &meta {
+                    Meta::NameValue(nv) => {
+                        if nv.path.is_ident("name") {
+                            if let Expr::Lit(expr_lit) = &nv.value {
+                                if let Lit::Str(lit_str) = &expr_lit.lit {
+                                    attrs.name = Some(lit_str.value());
+                                    continue;
+                                }
                             }
-                        }
-                        return Err(syn::Error::new_spanned(
-                            &nv.value,
-                            "expected string literal for `name`",
-                        ));
-                    } else if nv.path.is_ident("params") {
-                        if let Expr::Path(expr_path) = &nv.value {
-                            attrs.params = Some(Type::Path(syn::TypePath {
-                                qself: None,
-                                path: expr_path.path.clone(),
-                            }));
-                            continue;
-                        }
-                        return Err(syn::Error::new_spanned(
-                            &nv.value,
-                            "expected type for `params`",
-                        ));
-                    } else if nv.path.is_ident("affine") {
-                        if let Expr::Lit(expr_lit) = &nv.value {
-                            if let Lit::Bool(lit_bool) = &expr_lit.lit {
-                                attrs.affine = lit_bool.value();
+                            return Err(syn::Error::new_spanned(
+                                &nv.value,
+                                "expected string literal for `name`",
+                            ));
+                        } else if nv.path.is_ident("params") {
+                            if let Expr::Path(expr_path) = &nv.value {
+                                attrs.params = Some(Type::Path(syn::TypePath {
+                                    qself: None,
+                                    path: expr_path.path.clone(),
+                                }));
                                 continue;
                             }
+                            return Err(syn::Error::new_spanned(
+                                &nv.value,
+                                "expected type for `params`",
+                            ));
+                        } else if nv.path.is_ident("affine") {
+                            if let Expr::Lit(expr_lit) = &nv.value {
+                                if let Lit::Bool(lit_bool) = &expr_lit.lit {
+                                    attrs.affine = lit_bool.value();
+                                    continue;
+                                }
+                            }
+                            return Err(syn::Error::new_spanned(
+                                &nv.value,
+                                "expected boolean for `affine`",
+                            ));
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                &nv.path,
+                                format!(
+                                    "unknown `center` attribute `{}`; \
+                                     known attributes are: name, params, affine",
+                                    nv.path
+                                        .get_ident()
+                                        .map(|id| id.to_string())
+                                        .unwrap_or_else(|| "<unknown>".into())
+                                ),
+                            ));
                         }
+                    }
+                    _ => {
                         return Err(syn::Error::new_spanned(
-                            &nv.value,
-                            "expected boolean for `affine`",
+                            &meta,
+                            "unknown `center` attribute; expected a name=value attribute \
+                             such as `name = \"...\"`, `params = MyType`, or `affine = true`",
                         ));
                     }
                 }

affn-derive/src/frame.rs

@@ -284,9 +284,30 @@ pub(crate) fn parse_frame_attributes(input: &DeriveInput) -> syn::Result<FrameAt
                         } else if nv.path.is_ident("ellipsoid") {
                             attrs.ellipsoid =
                                 Some(syn::Ident::new(&value_str, proc_macro2::Span::call_site()));
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                &nv.path,
+                                format!(
+                                    "unknown `frame` attribute `{}`; \
+                                     known attributes are: name, polar, azimuth, \
+                                     distance, ellipsoid, inherent",
+                                    nv.path
+                                        .get_ident()
+                                        .map(|id| id.to_string())
+                                        .unwrap_or_else(|| "<unknown>".into())
+                                ),
+                            ));
                         }
                     }
-                    _ => {}
+                    _ => {
+                        return Err(syn::Error::new_spanned(
+                            &meta,
+                            "unknown `frame` attribute; expected a name=value attribute \
+                             such as `name = \"...\"`, `polar = \"...\"`, \
+                             `azimuth = \"...\"`, `distance = \"...\"`, \
+                             `ellipsoid = \"...\"`, or the bare flag `inherent`",
+                        ));
+                    }
                 }
             }
         }

src/cartesian/mod.rs

@@ -114,6 +114,6 @@ pub use xyz::XYZ;
 
 pub use direction::Direction;
 pub use position::{CenterParamsMismatchError, Position};
-pub use vector::{Displacement, Vector, Velocity};
+pub use vector::{Acceleration, Displacement, Force, Vector, Velocity};
 
 pub use line_of_sight::{line_of_sight, line_of_sight_with_distance, try_line_of_sight};

src/cartesian/vector.rs

@@ -389,6 +389,20 @@ pub type Displacement<F, U> = Vector<F, U>;
 /// Velocities represent rates of change of position.
 pub type Velocity<F, U> = Vector<F, U>;
 
+/// An acceleration vector (free vector with acceleration unit).
+///
+/// This is a semantic alias for [`Vector<F, U>`] where `U` is an acceleration
+/// unit (e.g. `Per<Per<Kilometer, Second>, Second>`).
+/// Accelerations represent the second time-derivative of position.
+pub type Acceleration<F, U> = Vector<F, U>;
+
+/// A force vector (free vector with force unit).
+///
+/// This is a semantic alias for [`Vector<F, U>`] where `U` is a force unit
+/// (e.g. `Newton`, `Kilonewton`).
+/// Forces represent the physical cause of acceleration via Newton's second law.
+pub type Force<F, U> = Vector<F, U>;
+
 // =============================================================================
 // Tests
 // =============================================================================