DEV Community: nabbisen

matten: コンパニオン crates と、次のステップへの移行

nabbisen — Wed, 08 Jul 2026 13:43:19 +0000

これは matten を紹介する全 4 回シリーズの最終回です。これまでの記事ではライブラリが生まれた背景、数値計算コア、dynamic feature による取り込みを紹介しました。今回はコンパニオン crates と、より重要なこととして、matten を使うのをやめる適切なタイミングについてです。

3 つのコンパニオン crates

matten ワークスペースはコアと並んで、3 つの小さなコンパニオン crates を公開しています。それぞれスコープが狭く、閉じています。いずれもコアの matten crates への依存は追加しません。

matten-ndarray — ndarray へのブリッジ

matten-ndarray は matten::Tensor と ndarray::ArrayD<f64> の間を変換します。それだけです。

use matten::Tensor;
use matten_ndarray::{from_arrayd, to_arrayd};

let t = Tensor::new(vec![1.0, 2.0, 3.0, 4.0], &[2, 2]);

let arr = to_arrayd(&t)?;    // Tensor      -> ArrayD<f64>
let back = from_arrayd(arr)?; // ArrayD<f64> -> Tensor

これは「受け渡しの瞬間」のために存在します。概念実証がある程度成長し、ホットパスで ndarray のパフォーマンスが必要になったとき、フラットな Vec<f64> データはそのまま移行できます。ステータス：プロダクションレディ。

matten-mlprep — 小さな前処理ヘルパー

matten-mlprep は、数値テンソルをどこか別のツールに渡す前に準備するための、シンプルで決定論的な関数を少し提供します。

use matten::Tensor;
use matten_mlprep::{add_bias_column, standardize_columns, train_test_split};

let x = Tensor::new(vec![1.0, 3.0, 5.0, 7.0], &[4, 1]);

let z = standardize_columns(&x)?;     // 列ごとに平均 0、標準偏差 1 に
let z = add_bias_column(&z)?;         // 切片列（1.0）を先頭に追加
let (train, test) = train_test_split(&z, 0.75)?;

minmax_scale_columns も使えます。モデルの学習、自動微分、乱数、隠れた状態は一切ありません。それらが必要になったら、本格的な ML crates を使ってください。この crates は意図的に前処理の手前で止まっています。ステータス：プロダクションレディ候補。

matten-data — 列名指定で CSV からテンソルへ

matten-data は、ヘッダー行付きの CSV ファイルからクリーンな数値テンソルへの変換を、列を名前で選びながら行うためのヘルパーです。

use matten_data::Table;

let csv = "sales,cost,note\n10,2,a\n20,,b\n30,4,c";
let tensor = Table::from_csv_str(csv)?
    .select_columns(["sales", "cost"])?  // 列を名前で選択
    .fill_missing(0.0)?                   // 欠損値を明示的にクリーニング
    .try_numeric()?                       // 変換
    .to_tensor()?;                        // -> matten::Tensor, シェイプ [3, 2]

この crates は設計上 CSV 専用です。JSON の取り込みが必要であれば、コアの matten crates にある from_json や from_json_dynamic を使ってください。ステータス：プロダクションレディ候補。

次のステップへ移行するタイミング

ここがこの記事で一番大事な部分かもしれません。

matten は初期段階の作業を想定しています。アルゴリズムを試す、データパイプラインの概要を描く、Rust での数値アイデアを素早く形にする。そういった用途です。いずれプロジェクトがその役割を超えることもあるでしょう。いつそうなるかについて、具体的に書いておきます。

ndarray や nalgebra にホットパスを移す のは、そこのベンチマーク結果が気になり始めたときです。同じ環境で測ると、matten の 64×64 行列積は ndarray や nalgebra の同等処理に比べておおむね 7〜9 倍の時間がかかります。一度だけ実行する計算なら問題ないことが多いですが、タイトなループの中で繰り返し呼ばれるなら話が変わります。matten-ndarray ブリッジでデータを受け渡せます。

ndarray に直接移行する のは、ストライドビュー、ゼロコピースライス、BLAS 連携が必要になったときです。matten のスライス API はデータをコピーします。ndarray のビューはしません。

専用の ML フレームワーク（Candle、Burn、tch-rs）に移行するのは、自動微分、モデルの学習、GPU アクセラレーションが必要になったときです。matten-mlprep は前処理をカバーしています。それらの代わりにはなりません。

matten をそのまま使い続ける のは、問題が小さく、データがメモリに十分収まり、実行時間よりも開発者の時間の方が貴重である間です。

このライブラリはまだ pre-1.0 です。数値計算コアは実用上安定しており、コンパニオン crates は production-ready 候補です。v1 は、開発者 / メンテナーが準備できたと判断したときにリリースします — スケジュールで決めるものではありません。フィードバックや Issue はリポジトリでご連絡ください。

リンク: crates.io · docs.rs · mdBook · リポジトリ

matten: Companion crates and when to move on

nabbisen — Wed, 08 Jul 2026 13:41:46 +0000

This is the last of four short posts about matten. The earlier posts covered why the library exists, the numeric core, and the dynamic ingestion feature. This one covers the companion crates and, more importantly, when the right answer is to stop using matten.

Three companion crates

The matten workspace publishes three small companion crates alongside the core.
Each has a narrow, closed scope. None of them adds a dependency to the core matten crate.

matten-ndarray — the bridge to ndarray

matten-ndarray converts between matten::Tensor and ndarray::ArrayD<f64>. That is all it does.

use matten::Tensor;
use matten_ndarray::{from_arrayd, to_arrayd};

let t = Tensor::new(vec![1.0, 2.0, 3.0, 4.0], &[2, 2]);

let arr = to_arrayd(&t)?;    // Tensor      -> ArrayD<f64>
let back = from_arrayd(arr)?; // ArrayD<f64> -> Tensor

This exists for the handoff moment: when a proof of concept has grown to the point where a hot path needs ndarray's performance, the flat Vec<f64> data moves across without re-encoding. Status: production-ready.

matten-mlprep — small preprocessing helpers

matten-mlprep provides a handful of plain, deterministic functions for preparing a numeric tensor before feeding it somewhere else.

use matten::Tensor;
use matten_mlprep::{add_bias_column, standardize_columns, train_test_split};

let x = Tensor::new(vec![1.0, 3.0, 5.0, 7.0], &[4, 1]);

let z = standardize_columns(&x)?;     // zero mean, unit std per column
let z = add_bias_column(&z)?;         // prepend a 1.0 intercept column
let (train, test) = train_test_split(&z, 0.75)?;

minmax_scale_columns is also available. There is no model training, no autograd, no randomness, and no hidden state. When you need those things, reach for a real ML crate — this one deliberately stops at the preprocessing step. Status: production-ready candidate.

matten-data — CSV to Tensor via named columns

matten-data handles the step between a CSV file with a header row and a clean numeric tensor, letting you select columns by name.

use matten_data::Table;

let csv = "sales,cost,note\n10,2,a\n20,,b\n30,4,c";
let tensor = Table::from_csv_str(csv)?
    .select_columns(["sales", "cost"])?  // pick numeric columns by name
    .fill_missing(0.0)?                   // clean missing values explicitly
    .try_numeric()?                       // convert
    .to_tensor()?;                        // -> matten::Tensor, shape [3, 2]

This crate is CSV-only by design. If you need JSON ingestion, that lives in the core matten crate (from_json, from_json_dynamic). Status: production-ready candidate.

When to move on

This is probably the more useful part of this post.

matten is designed for early-stage work: trying out an algorithm, sketching a data pipeline, getting a Rust numerical idea off the ground quickly. At some point a project may outgrow that role, and it is worth being specific about when that is.

Move a hot path to ndarray or nalgebra when benchmark numbers start to matter for that part of the code. A 64×64 matrix multiply in matten currently runs at roughly 7–9× the time of the equivalent in ndarray or nalgebra on the same machine. For a one-off computation that is usually fine; for something called in a tight loop it is not. The matten-ndarray bridge handles the data handoff.

Move to ndarray directly when you need strided views, zero-copy slicing, or BLAS integration. matten's slice API copies data; ndarray's views do not.

Move to a dedicated ML framework (Candle, Burn, tch-rs) when you need autograd, model training, or GPU acceleration. matten-mlprep covers preprocessing; it is not a substitute for any of those.

Stay with matten for as long as the problem is small, the data fits comfortably in memory, and developer time is more constrained than runtime.

The library is still pre-1.0. The numeric core is stable in practice, the companion crates are production-ready candidates, and v1 will come when the developers / maintainers are confident it is ready — not on a schedule. Feedback and issues are welcome on the repository.

Links: crates.io · docs.rs · mdBook · repository

matten: 不均一なデータを `--features dynamic` で扱う

nabbisen — Thu, 02 Jul 2026 09:00:00 +0000

これは matten を紹介する全 4 回シリーズの第 3 回です。前回は数値計算のコア部分を紹介しました。今回は雑然とした実世界のデータを取り込むしくみについてです。

課題事項

前回紹介した Tensor （数値テンソル）は、つくられた時点からクリーンです。すべてのセルが f64 です。データがすでにクリーンであれば、それで問題ありません。しかし、データが JSON API や CSV ファイル経由で投入され、その中に欠損セルや、整数と浮動小数点の混在、あるいは bool 値（フラグ）が含まれているような場合となると、どうでしょうか。話は変わって来ます。

dynamic feature は、そのような場合の助けになります。データ取り込みとクリーニングのレイヤーを追加します。ただし、これは第二の計算エンジンではありません — dynamic テンソルで直接算術演算はできません。考え方はもっとシンプルです。不均一なデータを取り込み、検査してクリーニングし、データが整ったと確信したら数値テンソルに明示的に変換します。

次のようにして有効化できます：

matten = { version = "0.28", features = ["dynamic"] }

混在データの取り込み

from_json_dynamic と from_csv_dynamic は、型が混在したデータを受け付けます。各セルは Element のバリアントに格納されます：Float、Int、Bool、Text、または None（JSON の null や CSV の空フィールド）。

use matten::{NumericPolicy, Tensor};

// 数値の種類が混在し、かつ欠損セルが存在する JSON テーブル
let json = "[[1, 2.5, null], [4.0, 5, 6]]";
let t = Tensor::from_json_dynamic(json)?;

assert!(t.is_dynamic());
assert_eq!(t.shape(), &[2, 3]);
assert_eq!(t.count_none(), 1);

同様の処理は CSV でも動きます：

use matten::Tensor;

let csv = "10.0,20.0,30.0\n40.0,,60.0\n70.0,80.0,\n"; // 空セルが 2 つ
let t = Tensor::from_csv_dynamic(csv)?;

assert_eq!(t.count_none(), 2);

フォーマットが異なるだけで、ワークフローは同じです。

欠損値の検査

クリーニングの前に、どこに欠損があるか確認できます：

// none_mask: セルごとに 0.0 / 1.0 の数値テンソル
let mask = t.none_mask();
assert_eq!(mask.get(&[0, 2]), Some(1.0)); // [0,2] に null
assert_eq!(mask.get(&[0, 0]), Some(0.0)); // 値あり

// schema_summary で型の内訳を読みやすく確認
println!("{}", t.schema_summary());
// 例: "Float: 4, Int: 1, None: 1"

数値テンソルへの変換

変換ステップは意図的に明示的にしています。try_numeric() は厳格です。None、Bool、Text が 1 つでもあれば変換を拒否します：

// データに null があるため失敗する
assert!(t.try_numeric().is_err());

try_numeric_with(policy) を使うと、各バリアントをどう扱うかを指定できます：

use matten::NumericPolicy;

// None を 0.0 として扱い、Int と Float はそのまま f64 に
let clean = t.try_numeric_with(NumericPolicy::default().none_as(0.0))?;

assert!(!clean.is_dynamic());
assert_eq!(clean.as_slice(), &[1.0, 2.5, 0.0, 4.0, 5.0, 6.0]);

その他の指定オプション：

// none_as_nan: 欠損を指定した値ではなく f64::NAN に
let p = NumericPolicy::default().none_as_nan();

// allow_bool: true → 1.0, false → 0.0
let p = NumericPolicy::default().allow_bool();

// allow_text_parse: テキストセルを f64 としてパースを試みる
let p = NumericPolicy::default().allow_text_parse();

// オプションを組み合わせる
let p = NumericPolicy::default().none_as(0.0).allow_bool();

// すべてのバリアントを受け入れる
let p = NumericPolicy::permissive();

変換前のクリーニング

変換ステップの前に欠損値を埋めることもできます：

// None をすべて 0.0 で埋める
let filled = t.fill_none(0.0);
assert!(filled.is_numeric_convertible());

// そのあと厳格に変換
let numeric = filled.try_numeric()?;

時系列データ向けに forward_fill_none（前の値で補完）も使えます。

dynamic でできないこと

dynamic feature には意図的に含まれていないものがあります：

dynamic テンソルでの算術演算は不可。事前に try_numeric() を実行してください。
dynamic テンソルの reshape、slice、reduction は不可。
dynamic テンソルの serde シリアライズは不可。

狙いは、きれいな受け渡しです。雑然とした入力 → 検査とクリーニング → 数値 Tensor → 通常の数値計算。この境界は意図的なものです。

リンク: crates.io · docs.rs · mdBook · リポジトリ

matten: Heterogeneous data with `--features dynamic`

nabbisen — Thu, 02 Jul 2026 08:00:00 +0000

This is the third of four short posts about matten. The previous post covered the numeric core. This one covers a separate feature: ingesting messy, real-world data.

The problem

The numeric Tensor in the previous post is clean by construction: every cell is an f64. That is fine when your data is already clean. It is less fine when it arrives from a JSON API or a CSV file that has missing cells, integer values alongside floats, or the occasional boolean flag.

The dynamic feature adds an ingestion-and-cleanup layer for that case. It is not a second compute engine — you cannot do arithmetic on a dynamic tensor directly. The idea is simpler: ingest heterogeneous data, inspect and clean it, then convert explicitly to a numeric tensor when you are confident the data is ready.

Enable it:

matten = { version = "0.28", features = ["dynamic"] }

Ingesting mixed data

from_json_dynamic and from_csv_dynamic accept data with mixed types. Each cell lands in an Element variant: Float, Int, Bool, Text, or None (for JSON null or an empty CSV field).

use matten::{NumericPolicy, Tensor};

// A JSON table with mixed numeric kinds and a missing cell
let json = "[[1, 2.5, null], [4.0, 5, 6]]";
let t = Tensor::from_json_dynamic(json)?;

assert!(t.is_dynamic());
assert_eq!(t.shape(), &[2, 3]);
assert_eq!(t.count_none(), 1);

The same on-ramp works for CSV:

use matten::Tensor;

let csv = "10.0,20.0,30.0\n40.0,,60.0\n70.0,80.0,\n"; // two empty cells
let t = Tensor::from_csv_dynamic(csv)?;

assert_eq!(t.count_none(), 2);

The format differs; the workflow does not.

Inspecting missing values

Before cleaning, you can see where the gaps are:

// none_mask: a numeric tensor of 0.0 / 1.0, one per cell
let mask = t.none_mask();
assert_eq!(mask.get(&[0, 2]), Some(1.0)); // null at [0,2]
assert_eq!(mask.get(&[0, 0]), Some(0.0)); // present

// schema_summary gives a readable type breakdown
println!("{}", t.schema_summary());
// e.g. "Float: 4, Int: 1, None: 1"

Converting to a numeric tensor

The conversion step is explicit by design. try_numeric() is strict and refuses if any None, Bool, or Text values are present:

// This fails — there is a null in the data
assert!(t.try_numeric().is_err());

try_numeric_with(policy) lets you state exactly what to do with each variant:

use matten::NumericPolicy;

// Treat None as 0.0; Int and Float both become f64
let clean = t.try_numeric_with(NumericPolicy::default().none_as(0.0))?;

assert!(!clean.is_dynamic());
assert_eq!(clean.as_slice(), &[1.0, 2.5, 0.0, 4.0, 5.0, 6.0]);

Other policy options:

// none_as_nan: missing → f64::NAN instead of a chosen sentinel
let p = NumericPolicy::default().none_as_nan();

// allow_bool: true → 1.0, false → 0.0
let p = NumericPolicy::default().allow_bool();

// allow_text_parse: try to parse text cells as f64
let p = NumericPolicy::default().allow_text_parse();

// Chain options together
let p = NumericPolicy::default().none_as(0.0).allow_bool();

// Accept all variants permissively
let p = NumericPolicy::permissive();

Cleaning before converting

You can also fill missing values before the conversion step:

// Replace every None with 0.0 in place
let filled = t.fill_none(0.0);
assert!(filled.is_numeric_convertible());

// Then convert strictly
let numeric = filled.try_numeric()?;

forward_fill_none is also available for time-series-style forward propagation.

What dynamic is not

A few things that are intentionally absent from the dynamic feature:

No arithmetic on dynamic tensors. Call try_numeric() first.
No dynamic reshape, slice, or reduction.
No serde for dynamic tensors.

The point is a clean handoff: messy input → inspect and clean → numeric Tensor → ordinary numeric work. That boundary is deliberate.

Links: crates.io · docs.rs · mdBook · repository

matten: `Tensor` コア

nabbisen — Tue, 30 Jun 2026 02:30:00 +0000

これは matten を紹介する全 4 回シリーズの第 2 回です。第 1 回では背景を説明しました。今回はライブラリの実際の使い方を紹介します。

はじめ方

# Cargo.toml
[dependencies]
matten = "0.28"

デフォルトの features には serde、json、csv が含まれています。依存関係をできるだけ小さくしたい場合は無効にします：

matten = { version = "0.28", default-features = false }

テンソルをつくる

use matten::Tensor; をインポートするだけです。ジェネリクスの型パラメータも、ライフタイムアノテーションも不要です。

use matten::Tensor;

// データとシェイプを明示してつくる
let a = Tensor::new(vec![1.0, 2.0, 3.0, 4.0], &[2, 2]);
assert_eq!(a.shape(), &[2, 2]);
assert_eq!(a.ndim(), 2);

// 便利なコンストラクタ
let z = Tensor::zeros(&[3, 3]);
let o = Tensor::ones(&[3, 3]);
let f = Tensor::full(&[2, 4], 5.0);

境界スタイルのコンストラクタを使うと、シェイプの不一致はパニックではなくエラーとして返ります：

use matten::{MattenError, Tensor};

let result = Tensor::try_new(vec![1.0, 2.0, 3.0], &[2, 2]);
assert!(matches!(result, Err(MattenError::Shape { .. })));

算術演算とブロードキャスト

演算子は参照を受け取ります。そのため、もとの値の所有権を保持したまま使えます。シェイプのブロードキャストは NumPy 方式の右揃えルールに従います。

use matten::Tensor;

let a = Tensor::new(vec![1.0, 2.0, 3.0, 4.0], &[2, 2]);
let b = Tensor::ones(&[2, 2]);

let c = &a + &b;          // [2.0, 3.0, 4.0, 5.0]
let d = &a * 2.0;         // スカラーブロードキャスト: [2.0, 4.0, 6.0, 8.0]

// 行ベクトルを行列全体にブロードキャスト
let row = Tensor::new(vec![1.0, 2.0], &[1, 2]);
let mat = Tensor::ones(&[3, 2]);
let result = &mat + &row; // シェイプ [3, 2]

シェイプ操作

use matten::Tensor;

let t = Tensor::new(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);

let flat = t.flatten();           // シェイプ [6]
let reshaped = t.reshape(&[3, 2])?;
let transposed = t.transpose()?;  // シェイプ [3, 2]

// リダクション
let s = t.sum();          // スカラー
let m = t.mean()?;
let col_sums = t.sum_axis(0)?;    // シェイプ [3]

JSON と CSV

どちらもデフォルトで有効です。境界部分では Result を返すので、不正な入力はパニックではなくエラーとして扱われます。

use matten::Tensor;

// JSON — 受け付け可能な形式
let t = Tensor::from_json(r#"{"shape":[2,2],"data":[1.0,2.0,3.0,4.0]}"#)?;
let t = Tensor::from_json("[[1.0, 2.0], [3.0, 4.0]]")?;

// ファイルから読み込む
let t = Tensor::load_json("data/tensor.json")?;

// CSV
let t = Tensor::from_csv("1.0,2.0,3.0\n4.0,5.0,6.0\n")?;
let t = Tensor::load_csv("data/matrix.csv")?;

serde 経由のシリアライズも使えます。json または serde feature が有効なとき、serde_json::to_string(&t) と serde_json::from_str(&json_str) で正しくラウンドトリップします。

エラーハンドリング

matten には、意図的に 2 つのエラー種別があります。

シェイプ操作（new での構築、reshape、スライス）はパニックし、わかりやすいメッセージを出します — 素早いプロトタイプ開発中に問題をすぐ見つけられるように。
外部境界の操作（from_json、from_csv、load_*）は常に Result<Tensor, MattenError> を返し、通常の不正入力ではパニックしません。実際のデータは常にクリーンとは限らないので。
- MattenError は #[non_exhaustive] です。気になるバリアントにマッチし、残りはワイルドカードで受けてください：

use matten::{MattenError, Tensor};

match Tensor::from_csv("1.0,not_a_number\n") {
    Ok(t) => println!("shape {:?}", t.shape()),
    Err(MattenError::Parse { .. }) => println!("不正な入力"),
    Err(e) => println!("その他のエラー: {e:?}"),
}

日常的な数値計算のコア部分は以上です。次の記事では少し異なる状況を扱います — 入力データがクリーンな f64 の行列ではないとき、つまり型が混在していたり、欠損値があったり、整数と浮動小数点が混在している場合です。

リンク: crates.io · docs.rs · mdBook · リポジトリ

matten とは: ファミリーカー式テンソルライブラリ — Rust 言語

nabbisen — Mon, 29 Jun 2026 20:30:00 +0000

多次元配列を扱うための小さな Rust ライブラリ matten を公開しました。このライブラリが生まれた背景を記載します。

Rust は数値計算やデータ処理に適した言語です。ただ、そういった作業を「始める」こと — 行列を用意して、足し算ができる状態にするだけ — が、プロトタイプの段階では必要以上に手間が掛かることがあります。

既存のライブラリは高機能で、しっかりとメンテナンスされています。パフォーマンスが必要なら ndarray や nalgebra を選ぶと良いでしょう。これらはプロダクション品質の数値計算コードに適したライブラリです。
ただしそこには学習コストが伴います。ジェネリクスの型パラメーター、ストレージの抽象化、ビュー型、ライフタイムの考慮。そのコストが見合う場面は多いです。しかし、概念実証の初日から常に見合うとは限りません。

matten が埋めようとしているのは、狭いけれど無視できないこともあるそのギャップです。初期段階の数値計算を、もう少し気軽に始められるようにする — 最初の 1 時間を、型システムではなく問題そのものに使えるように。

プロジェクトの説明で、これを「ファミリーカー」にたとえています。乗り込みやすく、運転が予測しやすく、日常のほとんどの用途に十分快適。レーシングカーではありません。そうなろうともしていません。

具体的には以下を意味します：

ジェネリクスなしのシンプルな一つだけの公開型、Tensor。
通常の使い方でユーザーがライフタイムを意識する場面は無し。
シェイプが合わないときは人間にとってわかりやすいエラーメッセージ。
JSON と CSV サポートがデフォルトで有効。データの入出力を手軽に。
コード全体で #![forbid(unsafe_code)]。

次のことは意味しません：ホットパスで既存ライブラリより速い。

この点はライブラリスコープ外です。このライブラリはその点を明示しています。プロトタイプが成熟してパフォーマンス要件を満たす必要が生じた時、その部分をより高性能なライブラリに移行するのが正しい判断です。

matten-ndarray はまさにそのための橋渡しとして存在しており、フラットな Vec<f64> のストレージ構造がデータの移動を簡単にしています。

P.S. — ライブラリ名の由来は "mathematical tensor" ...ではありません 😜 方言「待ってん (待ったねん)」からとっています。私たちは時間をつくりながら開発しました。使う人にとっても自分の時間の中で楽な気持ちで使えるものでありますように。

リンク: crates.io · docs.rs · mdBook · リポジトリ

matten: The core `Tensor`

nabbisen — Mon, 29 Jun 2026 13:21:42 +0000

This is the second of four short posts about matten. The first post explained the motivation. This one shows what the library looks like in practice.

Getting started

# Cargo.toml
[dependencies]
matten = "0.28"

The default feature set includes serde, json, and csv. If you want the smallest possible dependency footprint, you can turn them off:

matten = { version = "0.28", default-features = false }

Creating tensors

The whole import is use matten::Tensor;. No generic parameters, no lifetime annotations.

use matten::Tensor;

// From data and an explicit shape
let a = Tensor::new(vec![1.0, 2.0, 3.0, 4.0], &[2, 2]);
assert_eq!(a.shape(), &[2, 2]);
assert_eq!(a.ndim(), 2);

// Convenience constructors
let z = Tensor::zeros(&[3, 3]);
let o = Tensor::ones(&[3, 3]);
let f = Tensor::full(&[2, 4], 5.0);

Shape mismatches produce an actionable error rather than a panic when you use the boundary-style constructor:

use matten::{MattenError, Tensor};

let result = Tensor::try_new(vec![1.0, 2.0, 3.0], &[2, 2]);
assert!(matches!(result, Err(MattenError::Shape { .. })));

Arithmetic and broadcasting

The operators work on references, so you keep ownership of the originals. Shape broadcasting follows NumPy-style right-alignment rules.

use matten::Tensor;

let a = Tensor::new(vec![1.0, 2.0, 3.0, 4.0], &[2, 2]);
let b = Tensor::ones(&[2, 2]);

let c = &a + &b;          // [2.0, 3.0, 4.0, 5.0]
let d = &a * 2.0;         // scalar broadcast: [2.0, 4.0, 6.0, 8.0]

// Broadcasting a row across a matrix
let row = Tensor::new(vec![1.0, 2.0], &[1, 2]);
let mat = Tensor::ones(&[3, 2]);
let result = &mat + &row; // shape [3, 2]

Shape operations

use matten::Tensor;

let t = Tensor::new(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);

let flat = t.flatten();           // shape [6]
let reshaped = t.reshape(&[3, 2])?;
let transposed = t.transpose()?;  // shape [3, 2]

// Reductions
let s = t.sum();          // scalar
let m = t.mean()?;
let col_sums = t.sum_axis(0)?;    // shape [3]

JSON and CSV

Both are on by default. The API returns Result at the boundary, so a malformed input gives you an error rather than a panic.

use matten::Tensor;

// JSON — two accepted forms
let t = Tensor::from_json(r#"{"shape":[2,2],"data":[1.0,2.0,3.0,4.0]}"#)?;
let t = Tensor::from_json("[[1.0, 2.0], [3.0, 4.0]]")?;

// From a file
let t = Tensor::load_json("data/tensor.json")?;

// CSV
let t = Tensor::from_csv("1.0,2.0,3.0\n4.0,5.0,6.0\n")?;
let t = Tensor::load_csv("data/matrix.csv")?;

Serialisation goes through serde, so serde_json::to_string(&t) and serde_json::from_str(&json_str) round-trip correctly when the json or serde feature is active.

Error handling

matten has two deliberate error zones.

Internal shape operations (constructing from new, reshaping, slicing) panic with an actionable message — useful during fast prototyping because you see the problem immediately.
External boundary operations (from_json, from_csv, load_*) always return Result<Tensor, MattenError>, because real input data is not always clean.
- MattenError is #[non_exhaustive], so match on the variant you care about and use a wildcard for the rest:

use matten::{MattenError, Tensor};

match Tensor::from_csv("1.0,not_a_number\n") {
    Ok(t) => println!("got shape {:?}", t.shape()),
    Err(MattenError::Parse { .. }) => println!("bad input"),
    Err(e) => println!("other error: {e:?}"),
}

That covers the everyday numeric core. The next post covers something different: what happens when the input data is not a clean f64 matrix — when it has mixed types, missing values, or integers alongside floats.

Links: crates.io · docs.rs · mdBook · repository

matten Introduction: A family-car tensor library for Rust

nabbisen — Mon, 29 Jun 2026 01:45:50 +0000

I recently published matten, a small Rust library for working with multidimensional arrays. This is the first of four short posts introducing it. This one is about why it exists.

Rust is a great language for numerical and data-oriented work. But starting that work — just getting to the point where you have a matrix and can add two of them together — takes more effort than it probably should at the prototype stage.

The established libraries are capable and well-maintained. If you need performance, reach for ndarray or nalgebra. They are the right tools for production numerical code.
But they come with a learning curve: generic type parameters, storage abstractions, view types, lifetime considerations. That overhead is often worth it. It is not always worth it on day one of a proof of concept.

The gap matten fills is narrow and deliberate: making early-stage numerical Rust work feel less ceremonial, so you can spend the first hour on the problem rather than on the type system.

The project description borrows a modest analogy: a family car. Easy to get into, predictable to drive, comfortable enough for most everyday trips. Not a racing car. Not trying to be one.

Concretely that means:

One primary public type, Tensor, with no generic parameters.
No user-visible lifetimes in ordinary usage.
Human-readable error messages when shapes do not match.
JSON and CSV support on by default, for moving data in and out without ceremony.
#![forbid(unsafe_code)] throughout.

What it does not mean: faster than the alternatives on hot paths. The library is explicit about this. When a prototype grows into something performance-critical, the right move is to migrate that part of the work to a more capable library. matten-ndarray exists specifically for that handoff, and the flat Vec<f64> storage makes the data easy to move.

P.S. — The name is from mathematical tensor NOT 😜 It's from a Japanese charming dialect meaning "waited for". We took our time, and so can you.

Links: crates.io · docs.rs · mdBook · repository

mdka v2 Release

nabbisen — Tue, 21 Apr 2026 22:36:15 +0000

We have released v2 of mdka, a Rust-based HTML-to-Markdown converter. Originally developed as a core component for our internal systems, we have refined it into a general-purpose library for public release.

v2 strikes a practical balance between conversion quality and runtime efficiency—delivering readable output without sacrificing speed or memory. By focusing solely on its core task, this "Unix-style" tool achieves a lightweight footprint while maintaining competitive performance. We are pleased to share this utility with the community.

Full documentaions:
https://nabbisen.github.io/mdka-rs/

jwt-encde 1.1: npm packages for cross-platform published

nabbisen — Fri, 30 Jan 2026 09:11:20 +0000

jwt-encde, local and fast GUI JWT encoder/decoder, 1.1 🎉 now supports installation via npm 🤍

npm install -g jwt-encde
npx jwt-encde

jwt-encde: A simple way to handle JWTs on your desktop

nabbisen — Wed, 21 Jan 2026 13:20:08 +0000

If you're looking for a way to analyze JWTs without using online tools, jwt-encde might be helpful.

It is a dedicated GUI app that brings JWT decoding and encoding to your local desktop. The first stable version was released today, built with Rust and iced.

Why and when jwt-encde ?

100% Offline: Total privacy and information security. No logs, no tracking, no leaks.
Robust Design. Simple & Intuitive: Just a clean, high-performance and error-prevention UI ensures you focus on what's relevant to your current data.
Smart Analysis: Includes JSON syntax highlighting and a built-in Unix timestamp converter to make debugging easier.

And NOT when:

It doesn't support signature verification, as typically handled during integration tests with an IDaaS.

Available for Windows, macOS, and Linux: https://github.com/nabbisen/jwt-encde

MariaDB 11.4 on OpenBSD 7.8: Install

nabbisen — Wed, 03 Dec 2025 14:27:55 +0000

Summary

MariaDB is one of the most popular relational database management systems (RDBMS), forked from MySQL by some of the original developers.
It is open source licensed under GNU GPL 2, and ready for both community and enterprise use with long history and large knowledge to manage and maintain.

To Install it on OpenBSD, the solid and clean operating system, is easy thanks to the Package Management system ("ports") maintained by the great project and the community.

This post shows how to do it.

Environment

OS: OpenBSD 7.8
Database: MariaDB 11.4.9
- It's LTS.

Basic steps

Just a few !!

# pkg_add mariadb-server
# rcctl enable mysqld

# mariadb-install-db

# rcctl start mysqld

# mariadb-secure-installation
# # several questions will be given

All of the description is below.

Tutorial

Install the package

$ doas pkg_add mariadb-server

The result was:

quirks-7.147 signed on 2025-12-01T09:05:47Z
mariadb-server-11.4.9v1:(...): ok
mariadb-server-11.4.9v1: ok
The following new rcscripts were installed: /etc/rc.d/mysqld
See rcctl(8) for details.
New and changed readme(s):
    /usr/local/share/doc/pkg-readmes/mariadb-server

As above, the pkg-readme is brought as /usr/local/share/doc/pkg-readmes/mariadb-server.

Activate daemon

$ doas rcctl enable mysqld

Run `mariadb-install-db`

Create the default database:

$ doas mariadb-install-db

The result was:

Installing MariaDB/MySQL system tables in '/var/mysql' ...
OK


Two all-privilege accounts were created.
One is root@localhost, it has no password, but you need to
be system 'root' user to connect. Use, for example, sudo mariadb
The second is _mysql@localhost, it has no password either, but
you need to be the system '_mysql' user to connect.
After connecting you can set the password, if you would need to be
able to connect as any of these users with a password and without sudo

See the MariaDB Knowledgebase at https://mariadb.com/kb

You can start the MariaDB daemon with:
/etc/rc.d/mysqld start

Please report any problems at https://mariadb.org/jira

The latest information about MariaDB is available at https://mariadb.org/.

Consider joining MariaDB's strong and vibrant community:
https://mariadb.org/get-involved/

Start daemon

$ doas rcctl start mysqld
mysqld(ok)

Run `mariadb-secure-installation`

$ doas mariadb-secure-installation

Start (Before the questions)

NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
      SERVERS IN PRODUCTION USE!  PLEASE READ EACH STEP CAREFULLY!

Several questions given

Q1: Current root password

It must be none for the first time. Just push Enter.

In order to log into MariaDB to secure it, we'll need the current
password for the root user. If you've just installed MariaDB, and
haven't set the root password yet, you should just press enter here.

Enter current password for root (enter for none): 
OK, successfully used password, moving on...

At all the questions below, my choice is written down. Actually, they are up to your environment.

Q2: Use unix_socket authentication instead of root password

Setting the root password or using the unix_socket ensures that nobody
can log into the MariaDB root user without the proper authorisation.

You already have your root account protected, so you can safely answer 'n'.

Switch to unix_socket authentication [Y/n] n
 ... skipping.

Q3: Set root password

You already have your root account protected, so you can safely answer 'n'.

Change the root password? [Y/n] y
New password: 
Re-enter new password: 
Password updated successfully!
Reloading privilege tables..
 ... Success!

Q4: Remove anonymous users

By default, a MariaDB installation has an anonymous user, allowing anyone
to log into MariaDB without having to have a user account created for
them.  This is intended only for testing, and to make the installation
go a bit smoother.  You should remove them before moving into a
production environment.

Remove anonymous users? [Y/n] y
 ... Success!

Q5: Disallow root login remotely

Normally, root should only be allowed to connect from 'localhost'.  This
ensures that someone cannot guess at the root password from the network.

Disallow root login remotely? [Y/n] y
 ... Success!

Q6: Remove test database

By default, MariaDB comes with a database named 'test' that anyone can
access.  This is also intended only for testing, and should be removed
before moving into a production environment.

Remove test database and access to it? [Y/n] y
 - Dropping test database...
 ... Success!
 - Removing privileges on test database...
 ... Success!

Q7: Reload privilege tables

Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.

Reload privilege tables now? [Y/n] y
 ... Success!

End (The rest)

Cleaning up...

All done!  If you've completed all of the above steps, your MariaDB
installation should now be secure.

Thanks for using MariaDB!

Conclusion

You may confirm your daemon is fine with:

$ doas rcctl check mysqld
mysqld(ok)

Well, let's login to the server as client with root, the superuser:

$ mysql -u root -p

After entering the password, you must be welcomed:

Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 11
Server version: 11.4.9-MariaDB OpenBSD port: mariadb-server-11.4.9v1

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]>

The command line examples:

-- create database
CREATE DATABASE <database> \
    CHARACTER SET utf8mb4 \
    COLLATE utf8mb4_unicode_ci;

-- create user for it
GRANT ALL PRIVILEGES \
    ON <database>.* \
    TO <dbuser>@'localhost' \
    IDENTIFIED BY '<dbpass>';

-- reload privileges
FLUSH PRIVILEGES;

🎵 🐬 Happy storing digitally 🐬 🎵

DEV Community: nabbisen

matten: コンパニオン crates と、次のステップへの移行

3 つのコンパニオン crates

matten-ndarray — ndarray へのブリッジ

matten-mlprep — 小さな前処理ヘルパー

matten-data — 列名指定で CSV からテンソルへ

次のステップへ移行するタイミング

matten: Companion crates and when to move on

Three companion crates

matten-ndarray — the bridge to ndarray

matten-mlprep — small preprocessing helpers

matten-data — CSV to Tensor via named columns

When to move on

matten: 不均一なデータを `--features dynamic` で扱う

課題事項

混在データの取り込み

欠損値の検査

数値テンソルへの変換

変換前のクリーニング

dynamic でできないこと

matten: Heterogeneous data with `--features dynamic`

The problem

Ingesting mixed data

Inspecting missing values

Converting to a numeric tensor

Cleaning before converting

What dynamic is not

matten: `Tensor` コア

はじめ方

テンソルをつくる

算術演算とブロードキャスト

シェイプ操作

JSON と CSV

エラーハンドリング

matten とは: ファミリーカー式テンソルライブラリ — Rust 言語

matten: The core `Tensor`

Getting started

Creating tensors

Arithmetic and broadcasting

Shape operations

JSON and CSV

Error handling

matten Introduction: A family-car tensor library for Rust

mdka v2 Release

jwt-encde 1.1: npm packages for cross-platform published

jwt-encde: A simple way to handle JWTs on your desktop

MariaDB 11.4 on OpenBSD 7.8: Install

Summary

Environment

Basic steps

Tutorial

Install the package

Activate daemon

Run mariadb-install-db

Start daemon

Run mariadb-secure-installation

Start (Before the questions)

Several questions given

Q1: Current root password

Q2: Use unix_socket authentication instead of root password

Q3: Set root password

Q4: Remove anonymous users

Q5: Disallow root login remotely

Q6: Remove test database

Q7: Reload privilege tables

End (The rest)

Conclusion

Run `mariadb-install-db`

Run `mariadb-secure-installation`