Perturbation sensitivity implies high noise and suggests rate coding in cortex (London et al. 2010)

Accession:144027
"... The network simulations were also based on a previously published model(Latham et al. 2000), but with modifications to allow the addition and detection of extra spikes (see Supplementary Information, section 7)."
Reference:
1 . London M, Roth A, Beeren L, HÃ¤usser M, Latham PE (2010) Sensitivity to perturbations in vivo implies high noise and suggests rate coding in cortex. Nature 466:123-7 [PubMed]
Model Information (Click on a link to find other models with that property)
 Model Type: Realistic Network; Brain Region(s)/Organism: Neocortex; Cell Type(s): Channel(s): Gap Junctions: Receptor(s): Gene(s): Transmitter(s): Simulation Environment: C or C++ program; Model Concept(s): Activity Patterns; Implementer(s):
 / LondonEtAl2010 .hg readme.html derivs.c derivs.h dpoisson.c float2.c float2.h input lib.c lib.h main.c Makefile network.c network.h params.c params.h rgauss.c rgauss.h runge_kutta.c runge_kutta.h screenshot.png screenshot_v.png setgauss.c
```/*

Peter Latham
July, 1997

*/

#include "rgauss.h"

// constructor
rgauss::rgauss(int nn)
{
// set variables and reserve space
this->n = nn;
this->y = new float[n];

/* divide gaussian into n intervals of equal probability.
estimate area by expanding gaussian through quadratic.
width in y of section with probability r is given approximately by

dy = (r/f) - (f'/2f) * (r/f)^2 +[(f'/f)^2/2 - f''/6f)] * (r/f)^3

where   dy = y-y0, f=f(y0), f'=df(y0)/dy0, f''=d^f(y0)/dy0^2,
f is gaussian probability distribution. */

int n1, n2;
// sqrt2pi = sqrt(2*pi)
float r, sqrt2pi = 2.5066283, y0;
r=1/((float) n);

// determine where to start.  that depends on whether n is odd or even.
if (n%2 == 0)
{
y0 = 0;
n1=n/2;
n2=n/2-1;
}
else
{
float dum = 0.5*r*sqrt2pi;
y0 = dum*(1+dum*dum/6);
y[n/2] = 0;
n1=n/2+1;
n2=n/2-1;
}

for (int i=0; i < n/2; i++)
{
float dum = r*sqrt2pi*exp(y0*y0/2);
float dy = dum*(1+dum*(0.5*y0+dum*(0.5+y0*y0)/3));
y[n1+i] = y0+0.5*dy;
y[n2-i] = -(y0+0.5*dy);
y0 += dy;
}
}

// destructor
rgauss::~rgauss()
{
delete [] y;
}

float rgauss::ran(float sigma)
{
/*
return random number with gaussian distribution.

INPUT:
sigma	- standard deviation of Gaussian.

RETURNS:
gaussian distributed random number with standard deviation sigma.
*/
return sigma*y[(int) (n*drand())];
}

float rgauss::ran(float sigma, float xmin)
{
/*
return random number with gaussian distribution truncated below.

INPUT:
sigma	- standard deviation of Gaussian.
xmin	- minimum cutoff of truncated gaussian.

RETURNS:
truncated (from below) gaussian distributed random number
with standard deviation (before truncation) sigma.
*/
int i;

// find cutoff
for (i=0; i < n; i++) if (sigma*y[i] >= xmin) break;
if (i >= n) i=n-1;
float alpha = ((float) i) / ((float) n);

float x = sigma*y[(int) (n*(alpha + (1-alpha)*drand()))];

return x;
}

float rgauss::ran(float sigma, float xmin, float xmax)
{
/*
return random number with gaussian distribution truncated below
and above.

INPUT:
sigma	- standard deviation of Gaussian.
xmin	- minimum cutoff of truncated gaussian.
xmax	- maximum cutoff of truncated gaussian.

RETURNS:
truncated (from below and above) gaussian distributed random
number with standard deviation (before truncation) sigma.
*/
// check
if (xmax < xmin)
{
float tmp = xmin;
xmin = xmax;
xmax = tmp;
}
int i, j;

// find minimum cutoff
for (i=0; i < n; i++) if (sigma*y[i] >= xmin) break;
if (i >= n) i=n-1;

// find maximum cutoff
for (j=n-1; j >= 0; j--) if(sigma*y[j] <= xmax) break;
if (j < 0) j=0;

// check
if (i == j)
{
if (i == 0) j=1;
else i = j-1;
}

float alpha = ((float) i) / ((float) n);
float beta = ((float) j) / ((float) n);

float x = sigma*y[(int) (n*(alpha + (beta-alpha)*drand()))];

return x;
}

float* rgauss::ran(float sigma, int ntot)
{
/*
return array of random numbers with gaussian distribution.

INPUT:
sigma	- standard deviation of Gaussian.
ntot	- total number of random numbers to return.

RETURNS:
array of gaussian distributed random numbers with standard
deviation sigma.
*/
float* x = new float[ntot];
for (int i=0; i < ntot; i++) x[i] = sigma*y[(int) (n*drand())];
return x;
}

float* rgauss::ran(float sigma, int ntot, float xmin)
{
/*
return array of random numbers with gaussian distribution truncated
below.

INPUT:
sigma	- standard deviation of Gaussian.
ntot	- total number of random numbers to return.
xmin	- minimum cutoff of truncated gaussian.

RETURNS:
array of truncated (from below) gaussian distributed random numbers
with standard deviation (before truncation) sigma.
*/
int i;

// find cutoff
for (i=0; i < n; i++) if (sigma*y[i] >= xmin) break;
if (i >= n) i=n-1;
float alpha = ((float) i) / ((float) n);

float* x = new float[ntot];
for (i=0; i < ntot; i++)
x[i] = sigma*y[(int) (n*(alpha + (1-alpha)*drand()))];

return x;
}

float* rgauss::ran(float sigma, int ntot, float xmin, float xmax)
{
/*
return array of random numbers with gaussian distribution truncated
below and above.

INPUT:
sigma	- standard deviation of Gaussian.
ntot	- total number of random numbers to return.
xmin	- minimum cutoff of truncated gaussian.
xmax	- maximum cutoff of truncated gaussian.

RETURNS:
array of truncated (from below and above) gaussian distributed random
numbers with standard deviation (before truncation) sigma.
*/

// check
if (xmax < xmin)
{
float tmp = xmin;
xmin = xmax;
xmax = tmp;
}
int i, j;

// find minimum cutoff
for (i=0; i < n; i++) if (sigma*y[i] >= xmin) break;
if (i >= n) i=n-1;

// find maximum cutoff
for (j=n-1; j >= 0; j--) if(sigma*y[j] <= xmax) break;
if (j < 0) j=0;

// check
if (i == j)
{
if (i == 0) j=1;
else i = j-1;
}

float alpha = ((float) i) / ((float) n);
float beta = ((float) j) / ((float) n);

float* x = new float[ntot];
for (i=0; i < ntot; i++)
x[i] = sigma*y[(int) (n*(alpha + (beta-alpha)*drand()))];
return x;
}

float* rgauss::ran(
float sigma, int ntot, float xmin, float xmax,
float& alpha, float& beta)
{
/*
return array of random numbers with gaussian distribution truncated
below and above.

INPUT:
sigma	- standard deviation of Gaussian.
ntot	- total number of random numbers to return.
xmin	- minimum cutoff of truncated gaussian.
xmax	- maximum cutoff of truncated gaussian.
alpha, beta-
- if both these variables are nonnegative, then they are
used as cutoff values instead of xmin and xmax.
they are used for repeated calls to gauss with
the same xmin and xmax, since it can take a long
time to compute alpha and beta.

OUTPUT:
alpha, beta
- returned for use on next call, if desired.  see above.

RETURNS:
array of truncated (from below and above) gaussian distributed random
numbers with standard deviation (before truncation) sigma.
*/
float* x = new float[ntot];

if (alpha < 0 || beta < 0)
{
// ---compute alpha and beta from xmin and xmax

// check
if (xmax < xmin)
{
float tmp = xmin;
xmin = xmax;
xmax = tmp;
}
int i, j;

// find minimum cutoff
for (i=0; i < n; i++) if (sigma*y[i] >= xmin) break;
if (i >= n) i=n-1;

// find maximum cutoff
for (j=n-1; j >= 0; j--) if(sigma*y[j] <= xmax) break;
if (j < 0) j=0;

// check
if (i == j)
{
if (i == 0) j=1;
else i = j-1;
}

alpha = ((float) i) / ((float) n);
beta = ((float) j) / ((float) n);
}

// generate random numbers
for (int i=0; i < ntot; i++)
x[i] = sigma*y[(int) (n*(alpha + (beta-alpha)*drand()))];

return x;
}
```