Um neurônio Izhikevich é um modelo simples, mas bastante eficaz, de um neurônio biológico, projetado para uso em uma simulação discreta do tempo. Neste desafio de golfe, você estará implementando este modelo.

Parâmetros

Este modelo envolve apenas 7 variáveis ​​organizadas em 2 equações diferenciais, em comparação com as dezenas de parâmetros de um modelo fisiologicamente preciso.

• ve usão as duas variáveis ​​de estado do neurônio. Aqui, vé a variável "rápida" que representa o potencial da célula ao longo do tempo e ué a variável "lenta" que representa certas propriedades da membrana. A vvariável é a mais importante, pois esta é a saída da simulação.
• a, b, c, E dsão constantes que descrevem as propriedades do neurónio fixo. Diferentes tipos de neurônios têm constantes diferentes, dependendo do comportamento desejado. Notavelmente, cé o potencial de redefinição, que é o potencial de membrana ao qual a célula retorna após o pico.
• Irepresenta a corrente de entrada para o neurônio. Nas simulações de rede, isso mudará com o tempo, mas, para nossos propósitos, trataremos Icomo uma constante fixa.

O Modelo

Este modelo possui um pseudocódigo muito simples. Primeiro, pegamos os valores constantes de abcde os usamos para inicializar ve u:

v = c
u = b * c

Em seguida, percorreremos o código de simulação quantas vezes desejar. Cada iteração representa 1 milissegundo de tempo.

for 1..t:
  if v >= 30:    # reset after a spike
    v = c
    u = u + d
  v += 0.04*v^2 + 5*v + 140 - u + I
  u += a * (b*v - u)
  print v

Certas implementações do mundo real incluem etapas adicionais para precisão numérica, mas não as incluímos aqui.

Entrada

Como entrada, a sua função / programa deve ter os valores de a, b, c, d, I, e t(o número de passos de tempo para simular). Uma vez definido, nenhum desses parâmetros será alterado durante nossa simulação simples. A ordem de entrada não importa: você pode especificar a ordem em que seu programa aceita esses parâmetros.

Resultado

A saída será uma lista de números que representam o potencial de membrana da célula (fornecido por variável v) ao longo da simulação. A lista pode estar em qualquer formato apropriado.

Você tem a opção de incluir o 0º valor da simulação (a configuração inicial antes de qualquer momento) em sua saída. Por exemplo, para uma entrada de 0.02 0.2 -50 2 10 6(for a b c d I t), uma saída de

-50
-40
-16.04
73.876224
-42.667044096
-25.8262335380956
29.0355029192068

ou

-40
-16.04
73.876224
-42.667044096
-25.8262335380956
29.0355029192068

é aceitável.

Seus valores não precisam ser exatamente os mesmos que os acima, dependendo de como seu idioma lida com flutuações.

Implementação de referência

Aqui está uma implementação de TIO que escrevi no Perl para demonstrar o modelo. Os parâmetros são os de um neurônio "tagarelado" do artigo acima, e isso serve como uma demonstração de como esse modelo é capaz de recriar algumas das propriedades mais complexas dos neurônios, como alternar entre estados de alta e baixa atividade. Se você observar a saída, poderá ver onde o neurônio dispara imediatamente várias vezes, mas depois espera um pouco antes de disparar várias vezes (apesar da tensão de entrada da célula Iser constante o tempo todo).

R , 110 99 bytes

Função anônima que recebe 6 argumentos. Nada extravagante, apenas uma porta direta da implementação de referência. A atualização de u, ve a impressão de vtodas foram combinadas em uma única linha, graças ao fato de R's printretornar o valor que está sendo impresso, para que você possa usá-lo na atribuição. Muito obrigado a Giuseppe por salvar 11 bytes!

pryr::f({v=c;u=b*c;for(i in 1:t){if(v>=30){v=c;u=u+d}
u=a*b*(v=print((.04*v+6)*v+140+I-u))-a*u+u}})

Experimente online!

Limpo , 150 145 140 138 bytes

import StdEnv
$a b c d i t=map snd(iterate(\(u,v)#(w,n)=if(30.0<v)(c,u+d)(v,u)
#y=0.04*w*w+6.0*w+140.0-n+i
=(a*b*y-a*n+n,y))(b*c,c))%(0,t)

Experimente online!

Define a função $ :: Real Real Real Real Real Int -> [Real], implementando o algoritmo conforme descrito no OP, começando no 0º termo.

Python 2 , 100 bytes

a,b,c,d,I,t=input();v=c;u=b*c
exec"if v>=30:v=c;u+=d\nv=v*v/25+6*v+140-u+I;u+=a*(b*v-u);print v\n"*t

Experimente online!

Economizou 2 bytes graças a user71546 .

JavaScript (Node.js) , 107 ... 103 101 bytes

Contribuição de @apsillers

(a,b,c,d,I,t)=>[...Array(t)].map(_=>(v<30||(v=c,u+=d),v=v*(v/25+6)+140-u+I,u+=a*(b*v-u),v),u=b*(v=c))

Experimente online!

Abordagem original: 105 103 bytes. -1 byte Obrigado Arnauld e -2 bytes Obrigado @ Kamoroso94.

(a,b,c,d,I,t)=>{for(u=b*(v=c);t--;){v<30||(v=c,u+=d);v=v*(v/25+6)+140-u+I;u+=a*(b*v-u);console.log(v)}}

Experimente online!

Ou se os alertas popping estiverem OK, 101 ... 99 97 bytes (-1 byte Obrigado Arnauld, -2 bytes Obrigado @ Kamoroso94):

(a,b,c,d,I,t)=>{for(u=b*(v=c);t--;){v<30||(v=c,u+=d);v=v*(v/25+6)+140-u+I;u+=a*(b*v-u);alert(v)}}

var u, v;
var f = 
(a,b,c,d,I,t)=>{for(u=b*(v=c);t--;){v<30||(v=c,u+=d);v=v*(v/25+6)+140-u+I;u+=a*(b*v-u);alert(v)}}

function run() {
 f(...["a", "b", "c", "d", "I", "t"].map(x => document.getElementById(x).value * 1));
}

a = <input id="a" value="0.02"><br>
b = <input id="b" value="0.2"><br>
c = <input id="c" value="-50"><br>
d = <input id="d" value="2"><br>
I = <input id="I" value="10"><br>
t = <input id="t" value="6"><br>
<input type="button" value="Run" onclick="run()">

Ruby , 94 bytes

->a,b,c,d,i,t{v=c
u=b*c
t.times{v>=30?(v=c;u+=d):0
v+=0.04*v**2+5*v+140-u+i
u+=a*(b*v-u)
p v}}

Experimente online!

Outra porta simples da implementação de referência, um lambda que aceita 6 argumentos.

Haskell , 112 111 bytes

(a#b)c d i t|let r(v,u)|v>=30=r(c,u+d)|p<-0.04*v^2+6*v+140-u+i=(p,u+a*(b*p-u))=fst<$>take t(iterate r$r(c,b*c))

Experimente online!

Não gera o caso zero. Supõe que cnunca, >=30já que isso não faria sentido.

Nunca pensei que eu teria que usar uma wherecláusula em um código de golfe, mas existem variáveis ​​demais.

EDIT: Obrigado @Lynn por tirar um byte! Esqueci que você pode colocar letdeclarações em guardas. Claro que mata a legibilidade embora

Elemento , 81 bytes

_a;_b;_3:b~*u;_d;_I;_'[3:\.04*5+*140+u~-+I~++4:\
.`30<!b~*u~-+a~*u~+[d~+]u;[#2:]]

Experimente online! , Página Esolangs

Explicação:

_a;_b;_3:b~*u;_d;_I;_'[ ... ]

Esta parte do programa recebe entrada. Ele armazena constantes a, b, d, e Iem variáveis. A entrada para cnunca é armazenada em uma variável, mas permanece na pilha principal durante a execução. Três cópias são feitas: uma no topo para inicializar u, uma no meio para servir como inicial ve uma na parte inferior para servir como constante c. A entrada para té lançada imediatamente na pilha de controle para servir como base do loop FOR (o [...]) ao redor do restante do programa.

3:\.04*5+*140+u~-+I~++4:

Esta parte do programa pega o valor atual ve calcula o novo valor e, em seguida, vsão feitas quatro cópias do novo valor.

\
.`

A primeira cópia de vtem uma nova linha anexada e é impressa.

30<!

A segunda cópia de vé usada para testar se o neurônio disparou. O resultado desse teste é colocado na pilha de controle para uso posterior.

b~*u~-+a~*u~+

Esta parte calcula o "delta u", significando a quantidade a ser adicionada u.

[d~+]

Este bloco IF adiciona dà soma acima se o neurônio estiver disparando. Isso combina o que normalmente seriam duas atribuições em uma única atribuição.

u;

Isso armazena o valor atualizado de u.

[#2:]

Este bloco IF é uma continuação do bloco IF acima. Se o neurônio estiver disparando, exclua o valor atual de v(que agora está no topo da pilha principal) e substitua-o por uma duplicata de c(que esteve na parte inferior da pilha principal esse tempo todo).

E isso é basicamente tudo o que existe. Uma observação secundária é que essa coisa vaza memória: é preciso um extra "#para excluir a parte superior da pilha de controle (a condição IF avaliada) após cada iteração do loop.

Embora eu não diria que Element é a linguagem de golfe mais elegante, esse desafio me permite mostrar um recurso interessante: devido à divisão entre a pilha principal e a pilha de controle, posso pegar uma instrução IF e dividir a condição e o corpo em vários partes, entrelaçadas com código incondicional.

MATLAB, 111 bytes

function z(a,b,c,d,I,t)
v=c;u=b*c;for i=1:t if v>=30 v=c;u=u+d;end
v=.04*v^2+6*v+140-u+I
u=u+a*(b*v-u);
end
end

Implementação bastante simples, provavelmente pode ser melhorada ainda mais.