MatrixKit

Orquestador de Geometria Dinamica para Apple Silicon, impulsado por el motor interno MatrixKitCore. Procesa lotes masivos de datos sobre la arquitectura de Memoria Unificada (UMA) mediante despacho a GPU (Metal JIT) o CPU (Grand Central Dispatch), siguiendo la estela arquitectonica de CoreML, Metal y Accelerate.

Arquitectura de tres capas

┌─────────────────────────────────────────────────────────────┐
│  Capa de Alto Nivel — Swift                  (MatrixKit)      │
│  MatrixKitOrchestrator · Geometria · Tarea · Telemetria        │
├─────────────────────────────────────────────────────────────┤
│  Capa de Interoperabilidad — Objective-C++   (MatrixKitObjC) │
│  MatrixKitBridge  (NSError, ciclo de vida, serializacion)    │
├─────────────────────────────────────────────────────────────┤
│  Capa de Rendimiento Extremo — C++ / Metal   (MatrixKitCore)   │
│  Motor de geometria dinamica · 5 kernels · Metal JIT · GCD  │
└─────────────────────────────────────────────────────────────┘

• MatrixKitCore: el motor M4TRIX original, sin modificacion. Cinco pipelines, cada uno implementado en CPU (C++) y GPU (MSL): logica SAT, tensor (Leaky ReLU), cripto (mezclador de avalancha), fisica (raytracing), topologia (proyector + tanh). ABI C estable en MatrixKitCore.h.
• MatrixKitObjC: puente Objective-C++ que gestiona el ciclo de vida, serializa el acceso al motor global y traduce errores a NSError.
• MatrixKit: API Swift idiomatica con tipos fuertes y manejo de errores nativo.

Geometrias y tareas

Geometria	Caras	Bits	Uso
.eco	3	192	SAT ligero, logica simple
.cubo	6	384	Raytracing, topologia, cripto
.hyper	9	576	Inferencia IA, tensores

Tarea	Operacion
.logica	AND acumulado (SAT)
.tensor	Suma + Leaky ReLU (alpha 0.01)
.cripto	Mezclador de avalancha (efecto 50%)
.fisica	Interseccion Rayo-Esfera (radio 10)
.topologia	Proyector 6x6 + tanh

Uso

import MatrixKit

// Criptografia: hash de avalancha sobre 6 bloques
let m = try MatrixKitOrchestrator(geometria: .cubo, tarea: .cripto)
let hash = try m.inyectarYLeer([0x1A2B, 0x8B7A, 0x1122, 0x99AA, 0x0F1E, 0x8796])

// Logica SAT
let sat = try MatrixKitOrchestrator(geometria: .eco, tarea: .logica)
let r = try sat.inyectarYLeer([0xFFFFFFFFFFFFFFFF, 0x0, 0xFFFFFFFFFFFFFFFF])  // 0x0

// Tensor (IA): empaqueta Doubles en uint64
let ia = try MatrixKitOrchestrator(geometria: .hyper, tarea: .tensor)
let pesos = [0.55, 0.89, 0.12, 0.99, 0.45, 0.33, 0.11, 0.05, 0.77]
let payload = pesos.map { MatrixKitOrchestrator.empaquetar($0) }
let activacion = MatrixKitOrchestrator.desempaquetar(try ia.inyectarLote(payload, cantidadLotes: 1)[0])

// Lote masivo Zero-Copy
var entrada = [UInt64](repeating: 0, count: 1_000_000 * 6)
var salida  = [UInt64](repeating: 0, count: 1_000_000)
entrada.withUnsafeMutableBufferPointer { pIn in
    salida.withUnsafeMutableBufferPointer { pOut in
        do {
            try m.inyectarLoteZeroCopy(entrada: pIn, salida: pOut, cantidadLotes: 1_000_000)
        } catch {
            print("Error en Zero-Copy: \(error)")
        }
    }
}

Construccion

swift build
swift test

Requisitos

• macOS 13+
• Apple Silicon (M1/M2/M3/M4)

Notas tecnicas de integridad

El motor MatrixKitCore.mm es el motor de geometria dinamica original portado a Objective-C++. La cabecera MatrixKitCore.h refleja exactamente su bloque extern "C". Las capas superiores no reimplementan la matematica de los cinco pipelines.

Punto a tener presente en la ruta GPU: las tareas de punto flotante (tensor, fisica, topologia) usan en CPU una reinterpretacion directa de bits (memcpy a double), mientras que el kernel Metal convierte de double a float de 32 bits. Por tanto los resultados de punto flotante en GPU tienen precision float (~1e-7) frente a la precision double (~1e-15) de la CPU. La tarea cripto y la logica son exactas en ambas rutas (operan sobre enteros). Conviene validar la paridad CPU/GPU en hardware antes de depender de resultados de punto flotante en GPU.