Computational Neuroscience

// Computational Neuroscience Framework class ComputationalNeuroscience { constructor() { this.neurons = []; this.synapses = []; this.networks = []; this.simulations = []; } // Hodgkin-Huxley Model hodgkinHuxleyModel(neuron, timeStep, totalTime) { const simulation = { neuron: neuron, timeStep: timeStep, totalTime: totalTime, voltage: [], gating: [], current: [] }; // Initialize variables let V = neuron.restingPotential; let m = 0.05; // Na+ activation let h = 0.6; // Na+ inactivation let n = 0.3; // K+ activation // Simulation loop for (let t = 0; t < totalTime; t += timeStep) { // Calculate gating variables const alphaM = this.alphaM(V); const betaM = this.betaM(V); const alphaH = this.alphaH(V); const betaH = this.betaH(V); const alphaN = this.alphaN(V); const betaN = this.betaN(V); // Update gating variables m += timeStep * (alphaM * (1 - m) - betaM * m); h += timeStep * (alphaH * (1 - h) - betaH * h); n += timeStep * (alphaN * (1 - n) - betaN * n); // Calculate currents const INa = neuron.gNa * m**3 * h * (V - neuron.ENa); const IK = neuron.gK * n**4 * (V - neuron.EK); const IL = neuron.gL * (V - neuron.EL); // Update voltage V += timeStep * (neuron.Iinject - INa - IK - IL) / neuron.Cm; // Store results simulation.voltage.push(V); simulation.gating.push({m, h, n}); simulation.current.push({INa, IK, IL}); } return simulation; } // Integrate-and-Fire Model integrateAndFireModel(neuron, input, timeStep, totalTime) { const simulation = { neuron: neuron, input: input, timeStep: timeStep, totalTime: totalTime, voltage: [], spikes: [] }; let V = neuron.restingPotential; let refractoryTime = 0; for (let t = 0; t < totalTime; t += timeStep) { if (refractoryTime > 0) { refractoryTime -= timeStep; V = neuron.restingPotential; } else { // Update voltage V += timeStep * (input[t] - V + neuron.Iinject) / neuron.tau; // Check for spike if (V >= neuron.threshold) { simulation.spikes.push(t); V = neuron.resetPotential; refractoryTime = neuron.refractoryPeriod; } } simulation.voltage.push(V); } return simulation; } // Neural Network Simulation simulateNeuralNetwork(network, input, timeStep, totalTime) { const simulation = { network: network, input: input, timeStep: timeStep, totalTime: totalTime, activity: [], connectivity: [] }; // Initialize network state const neurons = network.neurons.map(n => ({ voltage: n.restingPotential, spikes: [], refractory: 0 })); // Simulation loop for (let t = 0; t < totalTime; t += timeStep) { const activity = []; // Update each neuron neurons.forEach((neuron, i) => { if (neuron.refractory > 0) { neuron.refractory -= timeStep; neuron.voltage = network.neurons[i].restingPotential; } else { // Calculate input from other neurons let totalInput = input[t] || 0; network.connections.forEach(conn => { if (conn.to === i) { const fromNeuron = neurons[conn.from]; if (fromNeuron.spikes.length > 0 && fromNeuron.spikes[fromNeuron.spikes.length - 1] > t - 5) { totalInput += conn.weight; } } }); // Update voltage neuron.voltage += timeStep * (totalInput - neuron.voltage) / network.neurons[i].tau; // Check for spike if (neuron.voltage >= network.neurons[i].threshold) { neuron.spikes.push(t); neuron.voltage = network.neurons[i].resetPotential; neuron.refractory = network.neurons[i].refractoryPeriod; } } activity.push(neuron.voltage); }); simulation.activity.push(activity); } return simulation; } // Synaptic Plasticity updateSynapticWeights(synapse, preSpike, postSpike, timeStep) { const plasticity = { synapse: synapse, preSpike: preSpike, postSpike: postSpike, weightChange: 0, newWeight: synapse.weight }; // STDP (Spike-Timing Dependent Plasticity) const timeDiff = postSpike - preSpike; if (timeDiff > 0) { // LTP (Long-Term Potentiation) plasticity.weightChange = synapse.Aplus * Math.exp(-timeDiff / synapse.tauPlus); } else { // LTD (Long-Term Depression) plasticity.weightChange = -synapse.Aminus * Math.exp(timeDiff / synapse.tauMinus); } plasticity.newWeight = Math.max(0, Math.min(1, synapse.weight + plasticity.weightChange)); return plasticity; } }