Phasor docs

using Phasor;

var shape = new HologramShape { KeyCapacity = 8, FlagBits = 4, TimePeriod = 9 };
var store = new Pleroma(shape);
store.Add(new HologramItem(Key: 10, Flags: 0b0011, Time: 2), 3);
store.Add(new HologramItem(Key: 20, Flags: 0b0111, Time: 5), 1);

// Bind with a one-item store: every item moves by the same key, flags and time shift.
var shift = new Pleroma(shape);
shift.Add(new HologramItem(Key: 1, Flags: 0b0001, Time: 1));
store.Bind(shift);

if (store.TryItems(out var items))
    foreach (var (item, count) in items)
        Console.WriteLine($"{item.Key}: flags {item.Flags}, time {item.Time}, count {count}");

using Phasor;

var store = new Pleroma(new HologramShape
{
    KeyCapacity = 4,
    FlagBits = 3,
    TimePeriod = 7,
    JointFaces = HologramFaces.Flags | HologramFaces.Time,
});
store.Add(new HologramItem(Key: 10, Flags: 0b001, Time: 0), 3);
store.Add(new HologramItem(Key: 20, Flags: 0b010, Time: 2), 2);
store.Add(new HologramItem(Key: 30, Flags: 0b100, Time: 4), 1);
Console.WriteLine("before flags " + string.Join(" ", store.Flags()));
Console.WriteLine("before times " + string.Join(" ", store.Times()));

// One kernel: 1x identity plus 2x (flip flag bit 0 and age one tick), applied to every item in one pass.
var kernel = new PleromaKernel(store.Shape);
kernel.Add(weight: 1L);
kernel.Add(flagMask: 0b001, timeShift: 1, weight: 2L);
store.Apply(kernel);

Console.WriteLine("after flags  " + string.Join(" ", store.Flags()));
Console.WriteLine("after times  " + string.Join(" ", store.Times()));

using Phasor;

var store = new Pleroma(new HologramShape { FlagBits = 4, KeyCapacity = 8 });
store.Add(new HologramItem(Key: 1, Flags: 0b0011), 2);   // two copies
store.Add(new HologramItem(Key: 1, Flags: 0b0110), 1);   // one copy
store.Add(new HologramItem(Key: 2, Flags: 0b0001), 3);   // three copies

long[] bitCounts = store.BitCounts();                     // exact count of items with each bit set
uint parity = store.FlagParity();                         // XOR of every stored word
Console.WriteLine($"{bitCounts[0]} {bitCounts[1]} {bitCounts[2]} {bitCounts[3]} parity {parity}");

using Phasor;

var stock = new CycleHologram(capacity: 8);
stock.Add(CycleHologram.Symbol("apples"), 10);
stock.Add(42, 5);                                   // integer symbols are exact
stock.Add(CycleHologram.Symbol("oranges"), 3);

if (stock.TryDecode(out var items))
{
    foreach (var (symbol, count) in items.OrderBy(i => i.Item2))
        Console.WriteLine($"count {count}");        // every count is exact
}

using Phasor;

var a = new CycleHologram(capacity: 4);
var b = new CycleHologram(capacity: 4);
for (ulong id = 0; id < 10_000; id++) { a.Add(id); b.Add(id); }
a.Add(777_001);        // only on A
b.Add(777_002, 2);     // only on B, two copies

byte[] wire = a.Serialize();                   // what A sends
Console.WriteLine($"wire size {wire.Length} bytes");
var delta = CycleHologram.Deserialize(wire);
delta.Subtract(b);                             // B subtracts its own hologram: A minus B
if (delta.TryDecode(out var diff))
    foreach (var (symbol, count) in diff.OrderBy(d => d.Item1))
        Console.WriteLine($"{symbol}: {count}");

using Phasor;

// Encode a number and some symbols
double[] five = PhasorCodec.Encode("5");
double[] three = PhasorCodec.Encode("3");
double[] age = PhasorCodec.Encode("age");
double[] name = PhasorCodec.Encode("name");
double[] hello = PhasorCodec.Encode("hello");

// Bind two numbers: adds them on the linear band
double[] fivePlusThree = PhasorCodec.Bind(five, three);
Console.WriteLine($"5 + 3 = {PhasorCodec.DecodeSum(fivePlusThree, max: 10)}");

// Bind each value to a role, bundle the pairs into one record, then unbind a role to read its value back
double[] record = PhasorCodec.Bundle(PhasorCodec.Bind(age, five), PhasorCodec.Bind(name, hello));
double[] ageField = PhasorCodec.Unbind(record, age);
Console.WriteLine($"age field matches 5 better than 3: {PhasorCodec.Correlate(ageField, five) > PhasorCodec.Correlate(ageField, three)}");

// For larger workloads and similarity search, HoloCodec is SIMD and configurable in width
var codec = new HoloCodec(dim: 1024);
double[] encoded = codec.Encode("hello");
Console.WriteLine($"HoloCodec self-similarity is positive: {HoloCodec.Dot(encoded, codec.Encode("hello")) > 0}");

using Phasor;

var dim = 256;  // Hologram default dimension

// A record is a superposition of role-value pairs
var nameRole = Hologram.FromSymbol("name", dim);
var lily = Hologram.FromSymbol("Lily", dim);
var ageRole = Hologram.FromSymbol("age", dim);
var seven = Hologram.FromNumber(7, dim);
var record = Hologram.Zero(dim) + nameRole * lily + ageRole * seven;   // bind, then bundle

// Unbind a role and correlate with candidate values
var nameField = record / nameRole;
var ageField = record / ageRole;
Console.WriteLine($"Name field has Lily:  {nameField.Correlate(lily):F2}");
Console.WriteLine($"Name field has John:  {nameField.Correlate(Hologram.FromSymbol("John", dim)):F2}");
Console.WriteLine($"Age field has 7:  {ageField.Correlate(seven):F2}");
Console.WriteLine($"Age field has 5:  {ageField.Correlate(Hologram.FromNumber(5, dim)):F2}");

using Phasor;

var dim = 256;

// Linear band: binding two numbers adds them
var sumEncoded = Hologram.FromNumber(3, dim) * Hologram.FromNumber(5, dim);
Console.WriteLine(PhasorCodec.DecodeSum(sumEncoded, max: 20));

// Log band: binding two numbers multiplies them
var productEncoded = Hologram.FromNumber(2, dim) * Hologram.FromNumber(4, dim);
Console.WriteLine(PhasorCodec.DecodeProduct(productEncoded, max: 16));

// In a loop, use the in-place methods: they reuse one buffer instead of allocating per call
double[] accumulator = new double[dim];
for (int i = 0; i < 100; i++)
    Hologram.BundleInto(accumulator, Hologram.FromNumber(i, dim).Reals);
Console.WriteLine($"accumulated {accumulator.Length} components");