@spiky-panda/core 0.1.0

package/dist/neuralnetwork/nn.weights.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nn.weights.js","sourceRoot":"","sources":["../../src/neuralnetwork/nn.weights.ts"],"names":[],"mappings":"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","sourcesContent":["/// <summary>\r\n/// WeightInit provides commonly used weight initialization strategies for neural networks.\r\n/// These initializers are not specific to MLPs and are widely used in various types of neural architectures\r\n/// including CNNs, RNNs, Transformers, and others, especially in deep learning.\r\n/// </summary>\r\nexport class WeightInit {\r\n    /// <summary>\r\n    /// Glorot/Xavier initialization.\r\n    /// Typically used with tanh or sigmoid activations.\r\n    /// Scales weights to keep variance roughly equal across layers.\r\n    /// </summary>\r\n    static Glorot(fanIn: number, fanOut: number): number {\r\n        const limit = Math.sqrt(6 / (fanIn + fanOut));\r\n        return (Math.random() * 2 - 1) * limit;\r\n    }\r\n\r\n    /// <summary>\r\n    /// He initialization.\r\n    /// Typically used with ReLU and its variants.\r\n    /// Helps prevent vanishing gradients in deep networks.\r\n    /// </summary>\r\n    static He(fanIn: number): number {\r\n        const limit = Math.sqrt(6 / fanIn);\r\n        return (Math.random() * 2 - 1) * limit;\r\n    }\r\n\r\n    /// <summary>\r\n    /// Gaussian initialization using the Box-Muller transform.\r\n    /// Can be used as a general-purpose initializer.\r\n    /// </summary>\r\n    static Normal(mean = 0, stdDev = 1): number {\r\n        let u = 1 - Math.random();\r\n        let v = 1 - Math.random();\r\n        return mean + stdDev * Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);\r\n    }\r\n\r\n    /// <summary>\r\n    /// Uniform initialization between min and max values.\r\n    /// </summary>\r\n    static Uniform(min = -1, max = 1): number {\r\n        return Math.random() * (max - min) + min;\r\n    }\r\n}\r\n\r\nexport enum WeightInitializerType {\r\n    /// <summary>\r\n    /// Glorot/Xavier initializer, typically used with tanh or sigmoid activations.\r\n    /// </summary>\r\n    Glorot = \"glorot\",\r\n\r\n    /// <summary>\r\n    /// He initializer, typically used with ReLU-like activations.\r\n    /// </summary>\r\n    He = \"he\",\r\n\r\n    /// <summary>\r\n    /// Normal (Gaussian) initializer using the Box-Muller transform.\r\n    /// </summary>\r\n    Normal = \"normal\",\r\n\r\n    /// <summary>\r\n    /// Uniform initializer between min and max values.\r\n    /// </summary>\r\n    Uniform = \"uniform\",\r\n}\r\n\r\n/// <summary>\r\n/// Interface for weight initialization strategies.\r\n/// </summary>\r\nexport interface IWeightInitializer {\r\n    type: WeightInitializerType;\r\n    next(): number;\r\n}\r\n\r\n/// <summary>\r\n/// Glorot/Xavier initializer class for use in builder chains.\r\n/// </summary>\r\nexport class Glorot implements IWeightInitializer {\r\n    private limit: number;\r\n\r\n    public constructor(fanIn: number, fanOut: number) {\r\n        this.limit = Math.sqrt(6 / (fanIn + fanOut));\r\n    }\r\n\r\n    public get type(): WeightInitializerType {\r\n        return WeightInitializerType.Glorot;\r\n    }\r\n\r\n    public next(): number {\r\n        return (Math.random() * 2 - 1) * this.limit;\r\n    }\r\n}\r\n\r\n/// <summary>\r\n/// He initializer class, typically used with ReLU-like activations.\r\n/// </summary>\r\nexport class He implements IWeightInitializer {\r\n    private limit: number;\r\n\r\n    public constructor(fanIn: number) {\r\n        this.limit = Math.sqrt(6 / fanIn);\r\n    }\r\n    public get type(): WeightInitializerType {\r\n        return WeightInitializerType.He;\r\n    }\r\n\r\n    public next(): number {\r\n        return (Math.random() * 2 - 1) * this.limit;\r\n    }\r\n}\r\n\r\n/// <summary>\r\n/// Normal (Gaussian) initializer using the Box-Muller transform.\r\n/// </summary>\r\nexport class Normal implements IWeightInitializer {\r\n    public constructor(private mean = 0, private stdDev = 1) {}\r\n\r\n    public get type(): WeightInitializerType {\r\n        return WeightInitializerType.Normal;\r\n    }\r\n\r\n    public next(): number {\r\n        let u = 1 - Math.random();\r\n        let v = 1 - Math.random();\r\n        return this.mean + this.stdDev * Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);\r\n    }\r\n}\r\n\r\n/// <summary>\r\n/// Uniform initializer between min and max.\r\n/// </summary>\r\nexport class Uniform implements IWeightInitializer {\r\n    public constructor(private min = -1, private max = 1) {}\r\n\r\n    public get type(): WeightInitializerType {\r\n        return WeightInitializerType.Uniform;\r\n    }\r\n\r\n    public next(): number {\r\n        return Math.random() * (this.max - this.min) + this.min;\r\n    }\r\n}\r\n"]}

package/dist/neuralnetwork/snn/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./spike.interfaces";
+export * from "./spike.runtime";
+export * from "./spike.stdp";

package/dist/neuralnetwork/snn/index.js

@@ -0,0 +1,4 @@
+export * from "./spike.interfaces";
+export * from "./spike.runtime";
+export * from "./spike.stdp";
+//# sourceMappingURL=index.js.map

package/dist/neuralnetwork/snn/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/neuralnetwork/snn/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC","sourcesContent":["export * from \"./spike.interfaces\";\r\nexport * from \"./spike.runtime\";\r\nexport * from \"./spike.stdp\";\r\n"]}

package/dist/neuralnetwork/snn/spike.interfaces.d.ts

@@ -0,0 +1,50 @@
+import { Nullable } from "../../types";
+import { IGraph, INode } from "../../graph";
+import { INeuron, ISynapse } from "../nn.interfaces";
+/**
+ * Represents a discrete spike event traveling through the network
+ */
+export interface ISpike {
+    timestamp: number;
+    amplitude: number;
+    source: INode;
+}
+/**
+ * Represents the internal state of a spiking neuron
+ */
+export interface ISpikeNeuronState {
+    membranePotential: number;
+    lastSpikeTime: Nullable<number>;
+    spikes: Array<ISpike>;
+}
+/**
+ * Represents a neuron in the Spiking Neural Network
+ */
+export interface ISpikeNeuron extends INeuron, ISpikeNeuronState {
+    threshold: number;
+    state: this;
+}
+/**
+ * Represents a synapse (connection between two neurons)
+ */
+export interface ISpikeSynapse extends ISynapse {
+    delay: number;
+    plasticity?: Nullable<boolean>;
+}
+/**
+ * Represents the entire Spiking Neural Network as a directed graph
+ */
+export interface ISnnGraph extends IGraph<ISpikeNeuron, ISpikeSynapse> {
+}
+/**
+ * Type guard for INeuron
+ */
+export declare function isNeuron(obj: unknown): obj is ISpikeNeuron;
+/**
+ * Type guard for ISynapse
+ */
+export declare function isSynapse(obj: unknown): obj is ISpikeSynapse;
+/**
+ * Type guard for ISnnGraph
+ */
+export declare function isSnnGraph(obj: unknown): obj is ISnnGraph;

package/dist/neuralnetwork/snn/spike.interfaces.js

@@ -0,0 +1,24 @@
+import { isGraph, isNode, isOlink } from "../../graph";
+/**
+ * Type guard for INeuron
+ */
+export function isNeuron(obj) {
+    return isNode(obj) && "membranePotential" in obj && "threshold" in obj && "lastSpikeTime" in obj && "spikes" in obj && Array.isArray(obj.spikes);
+}
+/**
+ * Type guard for ISynapse
+ */
+export function isSynapse(obj) {
+    return isOlink(obj) && "weight" in obj && "delay" in obj && obj.weight !== undefined && obj.delay !== undefined;
+}
+/**
+ * Type guard for ISnnGraph
+ */
+export function isSnnGraph(obj) {
+    return (isGraph(obj) &&
+        Array.isArray(obj.nodes) &&
+        Array.isArray(obj.links) &&
+        obj.nodes.every(isNeuron) &&
+        obj.links.every(isSynapse));
+}
+//# sourceMappingURL=spike.interfaces.js.map

package/dist/neuralnetwork/snn/spike.interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spike.interfaces.js","sourceRoot":"","sources":["../../../src/neuralnetwork/snn/spike.interfaces.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AA0CtE;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAY;IACjC,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,mBAAmB,IAAI,GAAG,IAAI,WAAW,IAAI,GAAG,IAAI,eAAe,IAAI,GAAG,IAAI,QAAQ,IAAI,GAAG,IAAI,KAAK,CAAC,OAAO,CAAE,GAAoB,CAAC,MAAM,CAAC,CAAC;AACvK,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,SAAS,CAAC,GAAY;IAClC,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,QAAQ,IAAI,GAAG,IAAI,OAAO,IAAI,GAAG,IAAK,GAAqB,CAAC,MAAM,KAAK,SAAS,IAAK,GAAqB,CAAC,KAAK,KAAK,SAAS,CAAC;AAC1J,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,GAAY;IACnC,OAAO,CACH,OAAO,CAAC,GAAG,CAAC;QACZ,KAAK,CAAC,OAAO,CAAE,GAA2C,CAAC,KAAK,CAAC;QACjE,KAAK,CAAC,OAAO,CAAE,GAA2C,CAAC,KAAK,CAAC;QAChE,GAA2C,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;QACjE,GAA2C,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CACtE,CAAC;AACN,CAAC","sourcesContent":["import { Nullable } from \"../../types\";\r\nimport { IGraph, INode, isGraph, isNode, isOlink } from \"../../graph\";\r\nimport { INeuron, ISynapse } from \"../nn.interfaces\";\r\n\r\n/**\r\n * Represents a discrete spike event traveling through the network\r\n */\r\nexport interface ISpike {\r\n    timestamp: number; // Time of the spike\r\n    amplitude: number; // Strength of the spike\r\n    source: INode; // Neuron that emitted the spike\r\n}\r\n\r\n/**\r\n * Represents the internal state of a spiking neuron\r\n */\r\nexport interface ISpikeNeuronState {\r\n    membranePotential: number; // Current charge of the neuron\r\n    lastSpikeTime: Nullable<number>; // Last time the neuron spiked\r\n    spikes: Array<ISpike>; // Spikes emitted by the neuron\r\n}\r\n\r\n/**\r\n * Represents a neuron in the Spiking Neural Network\r\n */\r\nexport interface ISpikeNeuron extends INeuron, ISpikeNeuronState {\r\n    threshold: number; // Activation threshold\r\n    state: this;\r\n}\r\n\r\n/**\r\n * Represents a synapse (connection between two neurons)\r\n */\r\nexport interface ISpikeSynapse extends ISynapse {\r\n    delay: number; // Time delay for spike transmission\r\n    plasticity?: Nullable<boolean>; // Whether STDP is applied\r\n}\r\n\r\n/**\r\n * Represents the entire Spiking Neural Network as a directed graph\r\n */\r\nexport interface ISnnGraph extends IGraph<ISpikeNeuron, ISpikeSynapse> {}\r\n\r\n/**\r\n * Type guard for INeuron\r\n */\r\nexport function isNeuron(obj: unknown): obj is ISpikeNeuron {\r\n    return isNode(obj) && \"membranePotential\" in obj && \"threshold\" in obj && \"lastSpikeTime\" in obj && \"spikes\" in obj && Array.isArray((obj as ISpikeNeuron).spikes);\r\n}\r\n\r\n/**\r\n * Type guard for ISynapse\r\n */\r\nexport function isSynapse(obj: unknown): obj is ISpikeSynapse {\r\n    return isOlink(obj) && \"weight\" in obj && \"delay\" in obj && (obj as ISpikeSynapse).weight !== undefined && (obj as ISpikeSynapse).delay !== undefined;\r\n}\r\n\r\n/**\r\n * Type guard for ISnnGraph\r\n */\r\nexport function isSnnGraph(obj: unknown): obj is ISnnGraph {\r\n    return (\r\n        isGraph(obj) &&\r\n        Array.isArray((obj as IGraph<ISpikeNeuron, ISpikeSynapse>).nodes) &&\r\n        Array.isArray((obj as IGraph<ISpikeNeuron, ISpikeSynapse>).links) &&\r\n        (obj as IGraph<ISpikeNeuron, ISpikeSynapse>).nodes.every(isNeuron) &&\r\n        (obj as IGraph<ISpikeNeuron, ISpikeSynapse>).links.every(isSynapse)\r\n    );\r\n}\r\n"]}

package/dist/neuralnetwork/snn/spike.runtime.d.ts

@@ -0,0 +1,31 @@
+import { ISpikeNeuron, ISnnGraph } from "./spike.interfaces";
+import { STDPFunction, ISTDPConfig } from "./spike.stdp";
+export declare class SNNRuntime {
+    /**
+     * Prepares input spikes from an ISnnGraph by binding input data to the graph's input nodes.
+     */
+    static prepareInputs(graph: ISnnGraph, inputData: number[]): Array<{
+        neuron: ISpikeNeuron;
+        amplitude: number;
+    }>;
+    private _stdpRule;
+    private _stdpConfig;
+    private _tick;
+    constructor(stdpRule?: STDPFunction, stdpConfig?: ISTDPConfig);
+    get tick(): number;
+    /**
+     * Injects spikes into the input neurons and propagates them through the network until no more spikes occur.
+     */
+    pulse(inputSpikes: Array<{
+        neuron: ISpikeNeuron;
+        amplitude: number;
+    }>): void;
+    /**
+     * Fires a neuron and resets its membrane potential.
+     */
+    private _fireNeuron;
+    /**
+     * Applies STDP learning to the active synapse using the configured rule and weight bounds.
+     */
+    private _applySTDP;
+}

package/dist/neuralnetwork/snn/spike.runtime.js

@@ -0,0 +1,90 @@
+import { STDP, DEFAULT_STDP_CONFIG } from "./spike.stdp";
+export class SNNRuntime {
+    /**
+     * Prepares input spikes from an ISnnGraph by binding input data to the graph's input nodes.
+     */
+    static prepareInputs(graph, inputData) {
+        if (graph.inputs.length !== inputData.length) {
+            throw new Error(`Input data size (${inputData.length}) does not match the number of graph inputs (${graph.inputs.length})`);
+        }
+        return graph.inputs.map((neuron, index) => ({
+            neuron,
+            amplitude: inputData[index],
+        }));
+    }
+    constructor(stdpRule, stdpConfig) {
+        this._tick = 0;
+        this._stdpRule = stdpRule ?? STDP.exponential();
+        this._stdpConfig = stdpConfig ?? DEFAULT_STDP_CONFIG;
+    }
+    get tick() {
+        return this._tick;
+    }
+    /**
+     * Injects spikes into the input neurons and propagates them through the network until no more spikes occur.
+     */
+    pulse(inputSpikes) {
+        let activeSpikes = [];
+        // Step 1: Inject initial spikes
+        for (const { neuron, amplitude } of inputSpikes) {
+            neuron.membranePotential += amplitude;
+            if (neuron.membranePotential >= neuron.threshold) {
+                activeSpikes.push(this._fireNeuron(neuron));
+            }
+        }
+        // Step 2: Process spikes continuously until no more spikes are generated
+        while (activeSpikes.length > 0) {
+            const nextSpikes = [];
+            this._tick++;
+            for (const spike of activeSpikes) {
+                const neuron = spike.source;
+                // Step 3: Propagate to connected neurons via 'onsc' links
+                const synapses = neuron.onsc();
+                if (synapses) {
+                    for (const synapse of synapses) {
+                        const postNeuron = synapse.ofin;
+                        // Apply synaptic weight
+                        postNeuron.membranePotential += spike.amplitude * synapse.weight;
+                        // If neuron reaches threshold, it fires
+                        if (postNeuron.membranePotential >= postNeuron.threshold) {
+                            const newSpike = this._fireNeuron(postNeuron);
+                            nextSpikes.push(newSpike);
+                            // Apply STDP only to the active synapse
+                            this._applySTDP(synapse);
+                        }
+                    }
+                }
+            }
+            // Continue propagation if new spikes were created
+            activeSpikes = nextSpikes;
+        }
+    }
+    /**
+     * Fires a neuron and resets its membrane potential.
+     */
+    _fireNeuron(neuron) {
+        this._tick++;
+        const spike = {
+            timestamp: this._tick,
+            amplitude: neuron.membranePotential,
+            source: neuron,
+        };
+        neuron.spikes.push(spike);
+        neuron.membranePotential = 0;
+        neuron.lastSpikeTime = spike.timestamp;
+        return spike;
+    }
+    /**
+     * Applies STDP learning to the active synapse using the configured rule and weight bounds.
+     */
+    _applySTDP(synapse) {
+        const preNeuron = synapse.oini;
+        const postNeuron = synapse.ofin;
+        if (preNeuron.lastSpikeTime !== null && postNeuron.lastSpikeTime !== null) {
+            const deltaT = postNeuron.lastSpikeTime - preNeuron.lastSpikeTime;
+            synapse.weight = this._stdpRule(deltaT, synapse.weight);
+            synapse.weight = Math.max(this._stdpConfig.minWeight, Math.min(this._stdpConfig.maxWeight, synapse.weight));
+        }
+    }
+}
+//# sourceMappingURL=spike.runtime.js.map

package/dist/neuralnetwork/snn/spike.runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spike.runtime.js","sourceRoot":"","sources":["../../../src/neuralnetwork/snn/spike.runtime.ts"],"names":[],"mappings":"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","sourcesContent":["import { ISpikeNeuron, ISnnGraph, ISpike, ISpikeSynapse } from \"./spike.interfaces\";\r\nimport { STDP, STDPFunction, ISTDPConfig, DEFAULT_STDP_CONFIG } from \"./spike.stdp\";\r\n\r\nexport class SNNRuntime {\r\n    /**\r\n     * Prepares input spikes from an ISnnGraph by binding input data to the graph's input nodes.\r\n     */\r\n    public static prepareInputs(graph: ISnnGraph, inputData: number[]): Array<{ neuron: ISpikeNeuron; amplitude: number }> {\r\n        if (graph.inputs.length !== inputData.length) {\r\n            throw new Error(`Input data size (${inputData.length}) does not match the number of graph inputs (${graph.inputs.length})`);\r\n        }\r\n\r\n        return graph.inputs.map((neuron, index) => ({\r\n            neuron,\r\n            amplitude: inputData[index],\r\n        }));\r\n    }\r\n\r\n    private _stdpRule: STDPFunction;\r\n    private _stdpConfig: ISTDPConfig;\r\n    private _tick: number = 0;\r\n\r\n    public constructor(stdpRule?: STDPFunction, stdpConfig?: ISTDPConfig) {\r\n        this._stdpRule = stdpRule ?? STDP.exponential();\r\n        this._stdpConfig = stdpConfig ?? DEFAULT_STDP_CONFIG;\r\n    }\r\n\r\n    public get tick(): number {\r\n        return this._tick;\r\n    }\r\n\r\n    /**\r\n     * Injects spikes into the input neurons and propagates them through the network until no more spikes occur.\r\n     */\r\n    public pulse(inputSpikes: Array<{ neuron: ISpikeNeuron; amplitude: number }>) {\r\n        let activeSpikes: ISpike[] = [];\r\n\r\n        // Step 1: Inject initial spikes\r\n        for (const { neuron, amplitude } of inputSpikes) {\r\n            neuron.membranePotential += amplitude;\r\n\r\n            if (neuron.membranePotential >= neuron.threshold) {\r\n                activeSpikes.push(this._fireNeuron(neuron));\r\n            }\r\n        }\r\n\r\n        // Step 2: Process spikes continuously until no more spikes are generated\r\n        while (activeSpikes.length > 0) {\r\n            const nextSpikes: ISpike[] = [];\r\n            this._tick++;\r\n\r\n            for (const spike of activeSpikes) {\r\n                const neuron = spike.source;\r\n\r\n                // Step 3: Propagate to connected neurons via 'onsc' links\r\n                const synapses = neuron.onsc<ISpikeSynapse>();\r\n                if (synapses) {\r\n                    for (const synapse of synapses) {\r\n                        const postNeuron = synapse.ofin as ISpikeNeuron;\r\n\r\n                        // Apply synaptic weight\r\n                        postNeuron.membranePotential += spike.amplitude * synapse.weight;\r\n\r\n                        // If neuron reaches threshold, it fires\r\n                        if (postNeuron.membranePotential >= postNeuron.threshold) {\r\n                            const newSpike = this._fireNeuron(postNeuron);\r\n                            nextSpikes.push(newSpike);\r\n\r\n                            // Apply STDP only to the active synapse\r\n                            this._applySTDP(synapse);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            // Continue propagation if new spikes were created\r\n            activeSpikes = nextSpikes;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Fires a neuron and resets its membrane potential.\r\n     */\r\n    private _fireNeuron(neuron: ISpikeNeuron): ISpike {\r\n        this._tick++;\r\n        const spike: ISpike = {\r\n            timestamp: this._tick,\r\n            amplitude: neuron.membranePotential,\r\n            source: neuron,\r\n        };\r\n\r\n        neuron.spikes.push(spike);\r\n        neuron.membranePotential = 0;\r\n        neuron.lastSpikeTime = spike.timestamp;\r\n\r\n        return spike;\r\n    }\r\n\r\n    /**\r\n     * Applies STDP learning to the active synapse using the configured rule and weight bounds.\r\n     */\r\n    private _applySTDP(synapse: ISpikeSynapse) {\r\n        const preNeuron = synapse.oini as ISpikeNeuron;\r\n        const postNeuron = synapse.ofin as ISpikeNeuron;\r\n\r\n        if (preNeuron.lastSpikeTime !== null && postNeuron.lastSpikeTime !== null) {\r\n            const deltaT = postNeuron.lastSpikeTime - preNeuron.lastSpikeTime;\r\n            synapse.weight = this._stdpRule(deltaT, synapse.weight);\r\n            synapse.weight = Math.max(this._stdpConfig.minWeight, Math.min(this._stdpConfig.maxWeight, synapse.weight));\r\n        }\r\n    }\r\n}\r\n"]}

package/dist/neuralnetwork/snn/spike.stdp.d.ts

@@ -0,0 +1,11 @@
+export type STDPFunction = (deltaT: number, weight: number) => number;
+export interface ISTDPConfig {
+    minWeight: number;
+    maxWeight: number;
+}
+export declare const DEFAULT_STDP_CONFIG: ISTDPConfig;
+export declare class STDP {
+    static exponential(learningRate?: number, tau?: number): STDPFunction;
+    static hebbian(learningRate?: number): STDPFunction;
+    static threshold(window?: number, potentiation?: number, depression?: number): STDPFunction;
+}

package/dist/neuralnetwork/snn/spike.stdp.js

@@ -0,0 +1,33 @@
+export const DEFAULT_STDP_CONFIG = {
+    minWeight: 0.01,
+    maxWeight: 1.0,
+};
+export class STDP {
+    static exponential(learningRate = 0.01, tau = 20) {
+        return (deltaT, weight) => {
+            if (deltaT > 0) {
+                return weight + learningRate * Math.exp(-deltaT / tau); // LTP
+            }
+            else if (deltaT < 0) {
+                return weight - learningRate * Math.exp(deltaT / tau); // LTD
+            }
+            return weight;
+        };
+    }
+    static hebbian(learningRate = 0.005) {
+        return (deltaT, weight) => {
+            return weight + learningRate * deltaT;
+        };
+    }
+    static threshold(window = 10, potentiation = 0.02, depression = 0.01) {
+        return (deltaT, weight) => {
+            if (Math.abs(deltaT) < window) {
+                return weight + potentiation;
+            }
+            else {
+                return weight - depression;
+            }
+        };
+    }
+}
+//# sourceMappingURL=spike.stdp.js.map

package/dist/neuralnetwork/snn/spike.stdp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spike.stdp.js","sourceRoot":"","sources":["../../../src/neuralnetwork/snn/spike.stdp.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,mBAAmB,GAAgB;IAC5C,SAAS,EAAE,IAAI;IACf,SAAS,EAAE,GAAG;CACjB,CAAC;AAEF,MAAM,OAAO,IAAI;IACN,MAAM,CAAC,WAAW,CAAC,eAAuB,IAAI,EAAE,MAAc,EAAE;QACnE,OAAO,CAAC,MAAc,EAAE,MAAc,EAAU,EAAE;YAC9C,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;gBACb,OAAO,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM;YAClE,CAAC;iBAAM,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpB,OAAO,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM;YACjE,CAAC;YACD,OAAO,MAAM,CAAC;QAClB,CAAC,CAAC;IACN,CAAC;IAEM,MAAM,CAAC,OAAO,CAAC,eAAuB,KAAK;QAC9C,OAAO,CAAC,MAAc,EAAE,MAAc,EAAU,EAAE;YAC9C,OAAO,MAAM,GAAG,YAAY,GAAG,MAAM,CAAC;QAC1C,CAAC,CAAC;IACN,CAAC;IAEM,MAAM,CAAC,SAAS,CAAC,SAAiB,EAAE,EAAE,eAAuB,IAAI,EAAE,aAAqB,IAAI;QAC/F,OAAO,CAAC,MAAc,EAAE,MAAc,EAAU,EAAE;YAC9C,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAAC;gBAC5B,OAAO,MAAM,GAAG,YAAY,CAAC;YACjC,CAAC;iBAAM,CAAC;gBACJ,OAAO,MAAM,GAAG,UAAU,CAAC;YAC/B,CAAC;QACL,CAAC,CAAC;IACN,CAAC;CACJ","sourcesContent":["export type STDPFunction = (deltaT: number, weight: number) => number;\r\n\r\nexport interface ISTDPConfig {\r\n    minWeight: number;\r\n    maxWeight: number;\r\n}\r\n\r\nexport const DEFAULT_STDP_CONFIG: ISTDPConfig = {\r\n    minWeight: 0.01,\r\n    maxWeight: 1.0,\r\n};\r\n\r\nexport class STDP {\r\n    public static exponential(learningRate: number = 0.01, tau: number = 20): STDPFunction {\r\n        return (deltaT: number, weight: number): number => {\r\n            if (deltaT > 0) {\r\n                return weight + learningRate * Math.exp(-deltaT / tau); // LTP\r\n            } else if (deltaT < 0) {\r\n                return weight - learningRate * Math.exp(deltaT / tau); // LTD\r\n            }\r\n            return weight;\r\n        };\r\n    }\r\n\r\n    public static hebbian(learningRate: number = 0.005): STDPFunction {\r\n        return (deltaT: number, weight: number): number => {\r\n            return weight + learningRate * deltaT;\r\n        };\r\n    }\r\n\r\n    public static threshold(window: number = 10, potentiation: number = 0.02, depression: number = 0.01): STDPFunction {\r\n        return (deltaT: number, weight: number): number => {\r\n            if (Math.abs(deltaT) < window) {\r\n                return weight + potentiation;\r\n            } else {\r\n                return weight - depression;\r\n            }\r\n        };\r\n    }\r\n}\r\n"]}

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+/** Alias type for value that can be null */
+export type Nullable<T> = T | null;
+export type SingleOrArray<T> = T | Array<T>;

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/** Alias type for value that can be null */\r\nexport type Nullable<T> = T | null;\r\n\r\nexport type SingleOrArray<T> = T | Array<T>;\r\n"]}

package/dist/utils/csv.d.ts

@@ -0,0 +1,6 @@
+export declare class CSVParser {
+    private delimiter;
+    constructor(delimiter?: string);
+    parse(csv: string): string[][];
+    private parseLine;
+}

package/dist/utils/csv.js

@@ -0,0 +1,36 @@
+export class CSVParser {
+    constructor(delimiter = ",") {
+        this.delimiter = delimiter;
+    }
+    parse(csv) {
+        const lines = csv.trim().split(/\r?\n/);
+        return lines.map((line) => this.parseLine(line));
+    }
+    parseLine(line) {
+        const cells = [];
+        let cell = "";
+        let inQuotes = false;
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            if (char === '"') {
+                if (inQuotes && line[i + 1] === '"') {
+                    cell += '"';
+                    i++; // skip next quote
+                }
+                else {
+                    inQuotes = !inQuotes;
+                }
+            }
+            else if (char === this.delimiter && !inQuotes) {
+                cells.push(cell);
+                cell = "";
+            }
+            else {
+                cell += char;
+            }
+        }
+        cells.push(cell);
+        return cells;
+    }
+}
+//# sourceMappingURL=csv.js.map

package/dist/utils/csv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv.js","sourceRoot":"","sources":["../../src/utils/csv.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,SAAS;IAGlB,YAAmB,SAAS,GAAG,GAAG;QAC9B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,GAAW;QACpB,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACxC,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IACrD,CAAC;IAEO,SAAS,CAAC,IAAY;QAC1B,MAAM,KAAK,GAAG,EAAE,CAAC;QACjB,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,IAAI,QAAQ,GAAG,KAAK,CAAC;QAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAErB,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;gBACf,IAAI,QAAQ,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;oBAClC,IAAI,IAAI,GAAG,CAAC;oBACZ,CAAC,EAAE,CAAC,CAAC,kBAAkB;gBAC3B,CAAC;qBAAM,CAAC;oBACJ,QAAQ,GAAG,CAAC,QAAQ,CAAC;gBACzB,CAAC;YACL,CAAC;iBAAM,IAAI,IAAI,KAAK,IAAI,CAAC,SAAS,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC9C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACjB,IAAI,GAAG,EAAE,CAAC;YACd,CAAC;iBAAM,CAAC;gBACJ,IAAI,IAAI,IAAI,CAAC;YACjB,CAAC;QACL,CAAC;QAED,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjB,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ","sourcesContent":["export class CSVParser {\r\n    private delimiter: string;\r\n\r\n    public constructor(delimiter = \",\") {\r\n        this.delimiter = delimiter;\r\n    }\r\n\r\n    public parse(csv: string): string[][] {\r\n        const lines = csv.trim().split(/\\r?\\n/);\r\n        return lines.map((line) => this.parseLine(line));\r\n    }\r\n\r\n    private parseLine(line: string): string[] {\r\n        const cells = [];\r\n        let cell = \"\";\r\n        let inQuotes = false;\r\n\r\n        for (let i = 0; i < line.length; i++) {\r\n            const char = line[i];\r\n\r\n            if (char === '\"') {\r\n                if (inQuotes && line[i + 1] === '\"') {\r\n                    cell += '\"';\r\n                    i++; // skip next quote\r\n                } else {\r\n                    inQuotes = !inQuotes;\r\n                }\r\n            } else if (char === this.delimiter && !inQuotes) {\r\n                cells.push(cell);\r\n                cell = \"\";\r\n            } else {\r\n                cell += char;\r\n            }\r\n        }\r\n\r\n        cells.push(cell);\r\n        return cells;\r\n    }\r\n}\r\n"]}

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./csv";

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./csv";
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC","sourcesContent":["export * from \"./csv\";\r\n"]}

package/package.json

@@ -0,0 +1,44 @@
+{
+    "name": "@spiky-panda/core",
+    "version": "0.1.0",
+    "description": "Core library for Spikypanda - geometry, graph, and neural network primitives",
+    "type": "module",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": ["dist"],
+    "sideEffects": false,
+    "scripts": {
+        "build": "npm run clean && npm run compile",
+        "clean": "rimraf dist bundle && rimraf tsconfig.build.tsbuildinfo",
+        "compile": "npm run compile:source",
+        "compile:source": "tsc -b tsconfig.build.json",
+        "watch:source": "tsc -b tsconfig.build.json -w",
+        "bundle": "webpack --mode production",
+        "bundle:dev": "webpack --mode development",
+        "bundle:watch": "webpack --mode development --watch",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": ["spikypanda", "geometry", "graph", "neural-network", "spiking-neural-network"],
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/GuillaumePelletier/spikypanda.git",
+        "directory": "packages/dev/core"
+    },
+    "peerDependencies": {
+        "reflect-metadata": "^0.2.2",
+        "tslib": "^2.8.1"
+    },
+    "devDependencies": {
+        "rimraf": "~6.0.1",
+        "ts-loader": "^9.5.0"
+    }
+}