GA-FuL Design-Prinzipien

// Derselbe Code funktioniert mit allen Skalartypen
var processor = XGaProcessor<T>.CreateEuclidean(scalarProcessor);
var v1 = processor.CreateComposer()
    .SetVectorTerm(0, a)
    .SetVectorTerm(1, b)
    .SetVectorTerm(2, c)
    .GetVector();
var v2 = processor.CreateComposer()
    .SetVectorTerm(0, x)
    .SetVectorTerm(1, y)
    .SetVectorTerm(2, z)
    .GetVector();
var result = v1.Gp(v2); // Geometrisches Produkt

// T kann sein: double, float, decimal, BigDecimal, Expr, etc.

// 100D-GA, sparse Multivektor mit 10 Komponenten
var composer = processor.CreateMultivectorComposer();
composer.SetTerm(indexSet1, scalar1);
composer.SetTerm(indexSet2, scalar2);
// ... 10 Terme total

var mv = composer.GetMultivector();

// Speicher: ~10 Skalare + 10 Index-Sets
// Voller Multivektor würde 2^100 Skalare benötigen!

// 1. Definiere Berechnungen in GA-FuL
var context = new MetaContext();
var x = context.CreateParameter("x");
var y = context.CreateParameter("y");
var scalarProcessor = context.ScalarProcessor;
var processor = XGaProcessor<IMetaExpression>.CreateEuclidean(scalarProcessor);

var v1 = processor.CreateComposer()
    .SetVectorTerm(0, x)
    .SetVectorTerm(1, y)
    .SetVectorTerm(2, 0)
    .GetVector();
var v2 = processor.CreateComposer()
    .SetVectorTerm(0, 1)
    .SetVectorTerm(1, 1)
    .SetVectorTerm(2, 1)
    .GetVector();
var result = v1.Gp(v2);

// 2. Optimiere
context.Optimize();

// 3. Generiere C++-Code
var cppCode = new CppCodeComposer().Generate(context);

// Resultat: Hochoptimierter C++-Code

// Koordinatenfreie, intuitive API
var point = cga.Encode.IpnsRound.Point(x, y, z);
var sphere = cga.Encode.IpnsRound.RealSphere(radius, cx, cy, cz);
var intersection = point.Op(sphere);

// Direkte Kontrolle über Skalare und Basis-Blades
var blade = processor.CreateBasisBlade(indexSet);
var scalar = scalarProcessor.Times(a, b);
var term = processor.CreateTerm(blade, scalar);

// Alle Prozessoren folgen demselben Muster
IScalarProcessor<T>
XGaProcessor<T>
XGaConformalSpace<T>

// Alle Composer folgen demselben Muster
XGaMultivectorComposer<T>
XGaKVectorComposer<T>

// Ein Template für alle Typen
XGaMultivector<double>
XGaMultivector<float>
XGaMultivector<Expr>  // Symbolisch
XGaMultivector<BigDecimal>

// Einheitliche API durch Extension Methods
multivector.Gp(other)      // Geometric Product
multivector.Op(other)      // Outer Product
multivector.Lcp(other)     // Left Contraction Product
multivector.Rcp(other)     // Right Contraction Product
multivector.Sp(other)      // Scalar Product
multivector.Reverse()      // Reverse
multivector.GradeInvolution() // Grade Involution

// Fluent API für Konstruktion
var mv = processor.CreateMultivectorComposer()
    .SetTerm(index1, scalar1)
    .SetTerm(index2, scalar2)
    .AddTerm(index3, scalar3)
    .GetMultivector();

// Klassisches OOP: Daten und Verhalten gekoppelt
class Multivector {
    private Dictionary<IIndexSet, T> data;

    public Multivector Gp(Multivector other) {
        // Verhalten im selben Objekt
    }
}

// DOP: Daten in thin wrapper
class XGaMultivector<T> {
    public IReadOnlyDictionary<int, XGaKVector<T>> Data { get; }
}

// Verhalten in statischen Extension Methods
static class XGaMultivectorExtensions {
    public static XGaMultivector<T> Gp<T>(
        this XGaMultivector<T> mv1,
        XGaMultivector<T> mv2
    ) {
        // Verhalten getrennt von Daten
    }
}

// NICHT eine spezielle Klasse mit interner Array-Struktur
// SONDERN generisches Dictionary
IReadOnlyDictionary<int, XGaKVector<T>>

IReadOnlyDictionary<IIndexSet, T>

// Zugriff ist einfach und transparent
var grade2Part = multivector[2];  // Dictionary-Zugriff
var scalar = kVector[indexSet];   // Dictionary-Zugriff

// Keine versteckten internen Strukturen

// 1. Composer für Konstruktion (Mutable während Build)
var composer = processor.CreateMultivectorComposer();
composer.SetTerm(index1, scalar1);
composer.SetTerm(index2, scalar2);
composer.AddTerm(index3, scalar3);

// 2. Finaler Multivektor (Immutable)
var multivector = composer.GetMultivector();

// 3. Multivector selbst ist read-only
// multivector.Data ist IReadOnlyDictionary<...>

// Schema: Interface definiert die Form
interface IIndexSet {
    int Count { get; }
    bool Contains(int index);
    IEnumerator<int> GetEnumerator();
}

// Repräsentation: Verschiedene Implementierungen
class EmptyIndexSet : IIndexSet { }
class SingleIndexSet : IIndexSet { }
class UInt64IndexSet : IIndexSet { }
class DenseIndexSet : IIndexSet { }
class SparseIndexSet : IIndexSet { }

// Code verwendet nur das Schema (Interface)
void ProcessBlade(IIndexSet indexSet) {
    // Funktioniert mit allen Implementierungen
    foreach (var index in indexSet) {
        // ...
    }
}

// Automatische Auswahl der besten Implementierung
var indexSet = IndexSetFactory.Create(indices);
// Gibt EmptyIndexSet, SingleIndexSet, UInt64IndexSet, etc. zurück

// Schema
IReadOnlyDictionary<IIndexSet, T>

// Implementierungen
class EmptyDictionary<K, V> : IReadOnlyDictionary<K, V>
class SingleItemDictionary<K, V> : IReadOnlyDictionary<K, V>
class Dictionary<K, V> : IReadOnlyDictionary<K, V>

// Interface als Schema
interface IIndexSet {
    int Count { get; }
    bool Contains(int index);
    IEnumerable<int> GetIndices();
}

// Implementierung mit read-only internen Strukturen
class UInt64IndexSet : IIndexSet {
    private readonly ulong _bitmap;  // Immutable

    public UInt64IndexSet(ulong bitmap) {
        _bitmap = bitmap;  // Set once, never changed
    }
}

class SparseIndexSet : IIndexSet {
    private readonly ImmutableHashSet<int> _indices;  // Immutable

    public SparseIndexSet(IEnumerable<int> indices) {
        _indices = indices.ToImmutableHashSet();
    }
}

// Thin wrapper
class XGaBasisBlade {
    public IIndexSet IndexSet { get; }  // Just holds data

    public XGaBasisBlade(IIndexSet indexSet) {
        IndexSet = indexSet;
    }
}

// Verhalten in Extension Methods
static class XGaBasisBladeExtensions {
    public static XGaBasisBlade Op(
        this XGaBasisBlade blade1,
        XGaBasisBlade blade2,
        XGaMetric metric
    ) {
        // Outer product logic here
    }
}

// Schema: Generic Dictionary
IReadOnlyDictionary<IIndexSet, T>

// Thin Wrapper mit Schema
class XGaKVector<T> {
    public IReadOnlyDictionary<IIndexSet, T> ScalarDictionary { get; }
    public XGaProcessor<T> Processor { get; }
}

class XGaMultivector<T> {
    public IReadOnlyDictionary<int, XGaKVector<T>> KVectorDictionary { get; }
    public XGaProcessor<T> Processor { get; }
}

// Mutable Builder
class XGaMultivectorComposer<T> {
    private Dictionary<IIndexSet, T> _terms = new();

    public XGaMultivectorComposer<T> SetTerm(IIndexSet id, T scalar) {
        _terms[id] = scalar;
        return this;
    }

    public XGaMultivector<T> GetMultivector() {
        // Select most efficient implementation
        if (_terms.Count == 0)
            return new ZeroMultivector<T>();
        if (_terms.Count == 1)
            return new SingleTermMultivector<T>(_terms.First());
        return new SparseMultivector<T>(_terms.ToImmutableDictionary());
    }
}

// Extension Methods für Operationen
static class XGaMultivectorExtensions {
    public static XGaMultivector<T> Gp<T>(
        this XGaMultivector<T> mv1,
        XGaMultivector<T> mv2
    ) {
        var composer = mv1.Processor.CreateMultivectorComposer();

        // Geometric product logic
        foreach (var (id1, scalar1) in mv1.Terms)
        foreach (var (id2, scalar2) in mv2.Terms) {
            var product = id1.Gp(id2, mv1.Processor.Metric);
            composer.AddTerm(product.IndexSet,
                mv1.Processor.ScalarProcessor.Times(
                    scalar1,
                    scalar2,
                    product.Sign
                )
            );
        }

        return composer.GetMultivector();
    }
}

// 1. Implementiere IScalarProcessor<T> (DOP-1: Verhalten)
public class MyCustomScalarProcessor : INumericScalarProcessor<MyScalar> {
    public MyScalar Add(MyScalar a, MyScalar b) => a + b;
    public MyScalar Times(MyScalar a, MyScalar b) => a * b;
    // ... weitere Operationen
}

// 2. Verwende es mit GA-FuL (DOP-4: Schema-Kompatibilität)
var scalarProcessor = new MyCustomScalarProcessor();
var processor = XGaProcessor<MyScalar>.CreateEuclidean(scalarProcessor);

// 3. Alle GA-Operationen funktionieren automatisch!
var v1 = processor.CreateComposer()
    .SetVectorTerm(0, a)
    .SetVectorTerm(1, b)
    .SetVectorTerm(2, c)
    .GetVector();
var v2 = processor.CreateComposer()
    .SetVectorTerm(0, x)
    .SetVectorTerm(1, y)
    .SetVectorTerm(2, z)
    .GetVector();
var result = v1.Gp(v2);

// 1. Implementiere IIndexSet (DOP-4: Schema)
public class BitVectorIndexSet : IIndexSet {
    private readonly BitVector32 _bits;  // DOP-3: Immutable

    public int Count => _bits.Data.CountBits();
    public bool Contains(int index) => _bits[1 << index];
    // ...
}

// 2. Verwende es (DOP-2: Generic Structure)
IIndexSet indexSet = new BitVectorIndexSet(bits);
var blade = new XGaBasisBlade(indexSet);

// 3. Alle Operationen funktionieren (DOP-1: Verhalten getrennt)
var result = blade.Op(otherBlade, metric);

// DOP-1: Verhalten als Extension Method hinzufügen
public static class MyCustomOperations {
    public static XGaMultivector<T> MyCustomProduct<T>(
        this XGaMultivector<T> mv1,
        XGaMultivector<T> mv2
    ) {
        // DOP-2: Arbeite mit generischen Datenstrukturen
        var composer = mv1.Processor.CreateMultivectorComposer();

        foreach (var (id1, s1) in mv1.Terms)
        foreach (var (id2, s2) in mv2.Terms) {
            // Nutze bestehende Strukturen
            var id = ComputeResultingId(id1, id2);
            var scalar = ComputeResultingScalar(s1, s2);
            composer.AddTerm(id, scalar);
        }

        // DOP-3: Returne immutable Objekt
        return composer.GetMultivector();
    }
}

// Verwendung
var result = multivector1.MyCustomProduct(multivector2);