use crate::seeds::{all_seed_tokens, SEED_POLES};
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
pub const DIMENSIONS: usize = 10_000;
const HDC_SENTINELS: &[&str] = &[
"okänd", "okand", "unknown", "unk", "<unk>", "n/a", "na", "none", "null", "?", "??", "...",
];
pub fn is_hdc_sentinel(concept: &str) -> bool {
let key = concept.trim().to_lowercase();
if key.is_empty() {
return true;
}
HDC_SENTINELS.contains(&key.as_str())
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum VocabRejectReason {
Sentinel,
LeadingDigits,
HdcSuffix,
PureNumber,
}
impl VocabRejectReason {
pub fn as_str(self) -> &'static str {
match self {
Self::Sentinel => "sentinel",
Self::LeadingDigits => "leading_digits",
Self::HdcSuffix => "hdc_suffix",
Self::PureNumber => "pure_number",
}
}
}
static VOCAB_REJECTED_SENTINEL: AtomicU64 = AtomicU64::new(0);
static VOCAB_REJECTED_LEADING_DIGITS: AtomicU64 = AtomicU64::new(0);
static VOCAB_REJECTED_HDC_SUFFIX: AtomicU64 = AtomicU64::new(0);
static VOCAB_REJECTED_PURE_NUMBER: AtomicU64 = AtomicU64::new(0);
fn bump_reject(reason: VocabRejectReason) {
let c = match reason {
VocabRejectReason::Sentinel => &VOCAB_REJECTED_SENTINEL,
VocabRejectReason::LeadingDigits => &VOCAB_REJECTED_LEADING_DIGITS,
VocabRejectReason::HdcSuffix => &VOCAB_REJECTED_HDC_SUFFIX,
VocabRejectReason::PureNumber => &VOCAB_REJECTED_PURE_NUMBER,
};
c.fetch_add(1, Ordering::Relaxed);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct VocabRejectTotals {
pub sentinel: u64,
pub leading_digits: u64,
pub hdc_suffix: u64,
pub pure_number: u64,
pub total: u64,
}
pub fn vocab_rejected_totals() -> VocabRejectTotals {
let sentinel = VOCAB_REJECTED_SENTINEL.load(Ordering::Relaxed);
let leading_digits = VOCAB_REJECTED_LEADING_DIGITS.load(Ordering::Relaxed);
let hdc_suffix = VOCAB_REJECTED_HDC_SUFFIX.load(Ordering::Relaxed);
let pure_number = VOCAB_REJECTED_PURE_NUMBER.load(Ordering::Relaxed);
VocabRejectTotals {
sentinel,
leading_digits,
hdc_suffix,
pure_number,
total: sentinel + leading_digits + hdc_suffix + pure_number,
}
}
pub fn vocab_reject_reason(concept: &str) -> Option<VocabRejectReason> {
let key = concept.trim().to_lowercase();
if key.is_empty() || HDC_SENTINELS.contains(&key.as_str()) {
return Some(VocabRejectReason::Sentinel);
}
if key.chars().all(|c| c.is_ascii_digit()) {
return Some(VocabRejectReason::PureNumber);
}
if key.contains("_hdc") {
return Some(VocabRejectReason::HdcSuffix);
}
if key.chars().next().is_some_and(|c| c.is_ascii_digit()) {
if let Some(rest) = key.split_once('_') {
if rest.0.chars().all(|c| c.is_ascii_digit()) {
return Some(VocabRejectReason::LeadingDigits);
}
}
}
None
}
pub fn is_vocab_rejected(concept: &str) -> bool {
vocab_reject_reason(concept).is_some()
}
fn fnv1a64(s: &str) -> u64 {
let mut hash: u64 = 0xcbf29ce484222325;
for b in s.as_bytes() {
hash ^= u64::from(*b);
hash = hash.wrapping_mul(0x100000001b3);
}
hash
}
pub struct HdcEngine {
dimensions: usize,
base_seed: u64,
concepts: HashMap<String, Vec<f32>>,
context: Vec<f32>,
perm: Vec<usize>,
inv_perm: Vec<usize>,
}
impl HdcEngine {
pub fn new(dimensions: usize) -> Self {
let seed = rand::thread_rng().gen();
Self::with_seed(dimensions, seed)
}
pub fn with_seed(dimensions: usize, seed: u64) -> Self {
let mut rng = StdRng::seed_from_u64(seed);
let mut perm: Vec<usize> = (0..dimensions).collect();
for i in (1..dimensions).rev() {
let j = rng.gen_range(0..=i);
perm.swap(i, j);
}
let mut inv_perm = vec![0usize; dimensions];
for (i, &p) in perm.iter().enumerate() {
inv_perm[p] = i;
}
let mut eng = Self {
dimensions,
base_seed: seed,
concepts: HashMap::new(),
context: vec![0.0; dimensions],
perm,
inv_perm,
};
eng.seed_from_poles();
eng.scrub_sentinels();
eng
}
pub fn dimensions(&self) -> usize {
self.dimensions
}
pub fn seed(&self) -> u64 {
self.base_seed
}
fn random_vector_for(&self, concept: &str) -> Vec<f32> {
let mut rng = StdRng::seed_from_u64(self.base_seed ^ fnv1a64(concept));
(0..self.dimensions)
.map(|_| if rng.gen_bool(0.5) { 1.0 } else { -1.0 })
.collect()
}
pub fn seed_from_poles(&mut self) {
for token in all_seed_tokens() {
let _ = self.encode(token);
}
for (pole, assoc) in SEED_POLES {
let mut names = vec![(*pole).to_string()];
names.extend(assoc.iter().map(|s| (*s).to_string()));
if let Some(bundle) = self.bundle_names(&names) {
self.concepts.insert((*pole).to_string(), bundle);
}
}
if let Some(warm) = self.bundle_names(&["system".into(), "jag".into(), "stillhet".into()]) {
self.context = warm;
}
}
pub fn encode(&mut self, concept: &str) -> Vec<f32> {
let key = concept.to_lowercase();
if let Some(reason) = vocab_reject_reason(&key) {
bump_reject(reason);
return vec![0.0; self.dimensions];
}
if let Some(v) = self.concepts.get(&key) {
return v.clone();
}
let v = self.random_vector_for(&key);
self.concepts.insert(key, v.clone());
v
}
pub fn scrub_sentinels(&mut self) -> usize {
let before = self.concepts.len();
self.concepts.retain(|k, _| vocab_reject_reason(k).is_none());
let removed = before.saturating_sub(self.concepts.len());
if removed > 0 {
if let Some(warm) =
self.bundle_names(&["system".into(), "jag".into(), "stillhet".into()])
{
self.context = warm;
}
}
removed
}
pub fn imprint(&mut self, concept: &str, alpha: f32) -> f32 {
if let Some(reason) = vocab_reject_reason(concept) {
bump_reject(reason);
return 0.0;
}
self.stimulate_soft(concept, alpha)
}
pub fn stimulate(&mut self, concept: &str) -> f32 {
if vocab_reject_reason(concept).is_some() {
return 0.0;
}
let v = self.encode(concept);
let sim = cosine_similarity(&v, &self.context);
self.blend_vector(&v, 0.1);
sim
}
pub fn permute_n(&self, v: &[f32], times: usize) -> Vec<f32> {
let mut out = v.to_vec();
for _ in 0..times {
out = self.permute(&out);
}
out
}
pub fn encode_ngram_sequence(&mut self, tokens: &[&str], n: usize) -> Vec<f32> {
let n = n.clamp(1, 5);
if tokens.is_empty() {
return self.encode("__empty_seq__");
}
let encoded: Vec<Vec<f32>> = tokens.iter().map(|t| self.encode(t)).collect();
let mut parts: Vec<Vec<f32>> = Vec::new();
let seq: Vec<Vec<f32>> = encoded
.iter()
.enumerate()
.map(|(i, v)| self.permute_n(v, i))
.collect();
parts.push(self.bundle(&seq));
if n >= 2 && encoded.len() >= n {
for start in 0..=(encoded.len() - n) {
let mut bound = encoded[start].clone();
for k in 1..n {
let pk = self.permute_n(&encoded[start + k], k);
bound = self.bind(&bound, &pk);
}
parts.push(bound);
}
} else if encoded.len() == 1 {
parts.push(encoded[0].clone());
}
self.bundle(&parts)
}
pub fn encode_text_sequence(&mut self, text: &str) -> Vec<f32> {
let toks: Vec<&str> = text
.split_whitespace()
.map(|w| w.trim_matches(|c: char| !c.is_alphanumeric() && c != '-'))
.filter(|w| w.len() > 1)
.take(48)
.collect();
self.encode_ngram_sequence(&toks, 3)
}
pub fn bind(&self, a: &[f32], b: &[f32]) -> Vec<f32> {
a.iter().zip(b.iter()).map(|(x, y)| x * y).collect()
}
pub fn unbind(&self, bound: &[f32], b: &[f32]) -> Vec<f32> {
self.bind(bound, b)
}
pub fn bundle(&self, vectors: &[Vec<f32>]) -> Vec<f32> {
let mut acc = vec![0.0f32; self.dimensions];
for v in vectors {
for (a, x) in acc.iter_mut().zip(v.iter()) {
*a += *x;
}
}
normalize(&mut acc);
acc
}
pub fn permute(&self, v: &[f32]) -> Vec<f32> {
let mut out = vec![0.0f32; self.dimensions];
for (i, &p) in self.perm.iter().enumerate() {
out[i] = v.get(p).copied().unwrap_or(0.0);
}
out
}
pub fn inverse_permute(&self, v: &[f32]) -> Vec<f32> {
let mut out = vec![0.0f32; self.dimensions];
for (i, &p) in self.inv_perm.iter().enumerate() {
out[i] = v.get(p).copied().unwrap_or(0.0);
}
out
}
pub fn similarity(&self, a: &[f32], b: &[f32]) -> f32 {
cosine_similarity(a, b)
}
pub fn context_vector(&self) -> &[f32] {
&self.context
}
pub fn blend_vector(&mut self, v: &[f32], alpha: f32) {
let a = alpha.clamp(0.0, 1.0);
let keep = 1.0 - a;
for (c, x) in self.context.iter_mut().zip(v.iter()) {
*c = keep * *c + a * *x;
}
normalize(&mut self.context);
}
pub fn integrate_sensors(&mut self, load: f64, temp: f64, hour_frac: f64, surprise_hint: f64) {
if load > 4.0 {
self.stimulate("rörelse");
self.stimulate("system");
} else {
self.stimulate("stillhet");
}
if temp > 70.0 {
self.stimulate("värme");
self.stimulate("energi");
}
if !(0.2..=0.8).contains(&hour_frac) {
self.stimulate("mörker");
} else {
self.stimulate("ljus");
}
if surprise_hint > 0.4 {
self.stimulate("kaos");
self.stimulate("överraskning");
}
self.stimulate("jag");
}
pub fn dominant(&self, k: usize) -> Vec<(String, f32)> {
let mut scored: Vec<(String, f32)> = self
.concepts
.iter()
.filter(|(n, _)| vocab_reject_reason(n).is_none())
.map(|(n, v)| (n.clone(), cosine_similarity(v, &self.context)))
.collect();
scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
scored.truncate(k);
scored
}
pub fn dominant_excluding(&self, k: usize, exclude: &[&str]) -> Vec<(String, f32)> {
let mut scored: Vec<(String, f32)> = self
.concepts
.iter()
.filter(|(n, _)| {
vocab_reject_reason(n).is_none()
&& !exclude
.iter()
.any(|e| e.eq_ignore_ascii_case(n.as_str()))
&& !n.starts_with("__role_")
&& !n.starts_with("__empty")
})
.map(|(n, v)| (n.clone(), cosine_similarity(v, &self.context)))
.collect();
scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
scored.truncate(k);
scored
}
pub fn stimulate_soft(&mut self, concept: &str, alpha: f32) -> f32 {
if vocab_reject_reason(concept).is_some() {
return 0.0;
}
let v = self.encode(concept);
let sim = cosine_similarity(&v, &self.context);
self.blend_vector(&v, alpha.clamp(0.0, 1.0));
sim
}
pub fn imprint_bundle(&mut self, names: &[String], alpha: f32) -> f32 {
let clean: Vec<String> = names
.iter()
.filter(|n| {
if let Some(reason) = vocab_reject_reason(n) {
bump_reject(reason);
false
} else {
true
}
})
.cloned()
.collect();
if clean.is_empty() {
return 0.0;
}
let vecs: Vec<Vec<f32>> = clean.iter().map(|n| self.encode(n)).collect();
let bundle = self.bundle(&vecs);
let sim = cosine_similarity(&bundle, &self.context);
self.blend_vector(&bundle, alpha.clamp(0.0, 1.0));
sim
}
pub fn score_named(&self, names: &[String]) -> Vec<(String, f32)> {
let mut out = Vec::new();
for n in names {
let key = n.to_lowercase();
if let Some(v) = self.concepts.get(&key) {
out.push((key, cosine_similarity(v, &self.context)));
}
}
out.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
out
}
pub fn unbind_sequence_position(&self, sequence: &[f32], position: usize) -> Vec<f32> {
let mut out = sequence.to_vec();
for _ in 0..position {
out = self.inverse_permute(&out);
}
out
}
pub fn recall_sequence_token(
&mut self,
sequence: &[f32],
position: usize,
candidates: &[&str],
) -> Option<(String, f32)> {
let probe = self.unbind_sequence_position(sequence, position);
let mut best: Option<(String, f32)> = None;
for c in candidates {
let v = self.encode(c);
let sim = cosine_similarity(&probe, &v);
if best.as_ref().map(|(_, s)| sim > *s).unwrap_or(true) {
best = Some(((*c).to_string(), sim));
}
}
best
}
pub fn context_drive(&self, n: usize) -> Vec<f32> {
if n == 0 || self.context.is_empty() {
return vec![0.0; n];
}
let step = (self.dimensions / n).max(1);
(0..n)
.map(|i| (self.context[(i * step) % self.dimensions] + 1.0) * 0.5)
.collect()
}
pub fn context_magnitude(&self) -> f64 {
let mag: f32 = self.context.iter().map(|x| x * x).sum::<f32>().sqrt();
mag as f64
}
pub fn concept_count(&self) -> usize {
self.concepts.len()
}
pub fn query_similar(&self, query: &[f32], k: usize) -> Vec<(String, f32)> {
let mut scored: Vec<(String, f32)> = self
.concepts
.iter()
.map(|(name, vec)| (name.clone(), cosine_similarity(query, vec)))
.collect();
scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
scored.truncate(k);
scored
}
pub fn concept_names(&self) -> Vec<&str> {
self.concepts.keys().map(|s| s.as_str()).collect()
}
pub fn harvest_seed(&mut self, name: &str, associations: &[String]) -> f32 {
for w in associations {
let _ = self.encode(w);
}
let mut names = associations.to_vec();
if !names.iter().any(|n| n == name) {
names.insert(0, name.to_string());
}
if let Some(bundle) = self.bundle_names(&names) {
self.concepts.insert(name.to_lowercase(), bundle);
}
self.stimulate(name)
}
pub fn decay_poles(&mut self, names: &[&str], amount: f32) {
let amount = amount.clamp(0.0, 0.8);
if amount < 1e-6 || names.is_empty() {
return;
}
let poles: Vec<Vec<f32>> = names
.iter()
.filter_map(|n| self.concepts.get(&n.to_lowercase()).cloned())
.collect();
for v in &poles {
let sim = cosine_similarity(&self.context, v);
if sim <= 0.02 {
continue;
}
let a = (amount * sim).clamp(0.0, 0.55);
for (c, x) in self.context.iter_mut().zip(v.iter()) {
*c -= a * *x;
}
}
normalize(&mut self.context);
}
pub const NOISE_POLES: &'static [&'static str] = &[
"relation",
"du",
"bro",
"jag",
"btc",
"eth",
"long",
"short",
"leverage",
"bps",
"kan",
"common",
"break",
"history",
"alert",
"block",
"content-filter",
"shannon-hartley",
"anmärkningsvärt",
];
fn bundle_names(&mut self, names: &[String]) -> Option<Vec<f32>> {
if names.is_empty() {
return None;
}
let vecs: Vec<Vec<f32>> = names.iter().map(|n| self.encode(n)).collect();
Some(self.bundle(&vecs))
}
}
fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
let mut dot = 0.0f32;
let mut na = 0.0f32;
let mut nb = 0.0f32;
for (x, y) in a.iter().zip(b.iter()) {
dot += x * y;
na += x * x;
nb += y * y;
}
let d = na.sqrt() * nb.sqrt();
if d < 1e-12 {
0.0
} else {
dot / d
}
}
pub fn pack_bipolar(v: &[f32]) -> Vec<u8> {
let mut out = vec![0u8; v.len().div_ceil(8)];
for (i, &x) in v.iter().enumerate() {
if x >= 0.0 {
out[i / 8] |= 1 << (i % 8);
}
}
out
}
pub fn unpack_bipolar(packed: &[u8], dimensions: usize) -> Vec<f32> {
let mut out = vec![-1.0f32; dimensions];
for i in 0..dimensions {
let byte = packed.get(i / 8).copied().unwrap_or(0);
if byte & (1 << (i % 8)) != 0 {
out[i] = 1.0;
}
}
out
}
fn normalize(v: &mut [f32]) {
let mag: f32 = v.iter().map(|x| x * x).sum::<f32>().sqrt();
if mag > 1e-12 {
for x in v.iter_mut() {
*x /= mag;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bind_unbind_roundtrip() {
let mut h = HdcEngine::with_seed(512, 42);
let a = h.encode("alpha_probe");
let b = h.encode("beta_probe");
let bound = h.bind(&a, &b);
let recovered = h.unbind(&bound, &b);
assert!(h.similarity(&recovered, &a) > 0.9);
}
#[test]
fn pack_bipolar_roundtrip_10k() {
let mut h = HdcEngine::with_seed(DIMENSIONS, 7);
h.stimulate("sverige");
h.stimulate("demokrati");
let packed = pack_bipolar(h.context_vector());
assert_eq!(packed.len(), DIMENSIONS.div_ceil(8));
let unpacked = unpack_bipolar(&packed, DIMENSIONS);
assert_eq!(unpacked.len(), DIMENSIONS);
for (a, b) in h.context_vector().iter().zip(unpacked.iter()) {
assert_eq!(a >= &0.0, b >= &0.0);
}
let sim = h.similarity(h.context_vector(), &unpacked);
assert!(sim > 0.9, "bipolar pack roundtrip sim={sim}");
}
#[test]
fn zero_vector_similarity_is_zero() {
let h = HdcEngine::with_seed(64, 1);
let z = vec![0.0f32; 64];
let a = vec![1.0f32; 64];
assert_eq!(h.similarity(&z, &a), 0.0);
assert_eq!(h.similarity(&z, &z), 0.0);
}
}