int main(int argc, char **argv) {
vb::Hub H("Deterministic Fourier law", argc, argv, "a=2,b=.2394879347,n=500,m=1000,t=100");
size_t nn = H['n'], nn2 = nn / 2, mm = H['m'], tt = H['t'];
state::a = H['a'];
state::b = H['b'];
std::vector<double> profile(nn, 0), boltzmann(mm, 0), var(tt, 0);
vb::ProgressBar PB(mm);
for (size_t i = 0; i < mm; ++i) {
Model M(nn);
M[nn2].v = 1;
for (size_t t = 0; t < tt; ++t) {
PB.set(i);
M.swipe();
double v = 0;
for (size_t k = 0; k < nn; ++k) v += double((k - nn2) * (k - nn2)) * M[k].v * M[k].v;
var[t] += v;
}
for (size_t k = 0; k < nn; ++k) profile[k] += M[k].v * M[k].v;
boltzmann[i] = M[nn / 2].v;
}
{
std::ofstream of("out.profile");
for (auto u : profile) of << u << std::endl;
}
{
std::ofstream of("out.variance");
for (auto u : var) of << u << std::endl;
}
{
auto nclass = size_t(sqrt(double(H['m'])));
double bmin = 0, bmax = 0;
for (auto b : boltzmann) {
bmin = std::min(bmin, b);
bmax = std::max(bmax, b);
}
std::vector<int> data(nclass);
for (auto b : boltzmann) data[unsigned((nclass - .01) * (b - bmin) / (bmax - bmin))]++;
std::ofstream of("out.boltzmann");
for (size_t i = 0; i < nclass; ++i) of << bmin + i * (bmax - bmin) / nclass << " " << data[i] << std::endl;
}
}
void StateActionAlgorithm::explore( State * state, Action * action, double explorationRate, string explorationType, bool endOfEpisode ) {
if ( explorationType.compare("boltzmann") == 0 ) {
boltzmann( state, action, explorationRate ) ;
} else if ( explorationType.compare("egreedy") == 0 ) {
egreedy( state, action, explorationRate ) ;
} else if ( explorationType.compare("gaussian") == 0 ) {
cout << "You are trying to use gaussian exploration for an algorithm that" << endl ;
cout << "does not support it. Please check your parameter file." << endl ;
#ifdef WIN32
char end;
cin>>end;
#endif
exit(-1) ;
} else {
void derivs_four(const double* y, double* dydt, const double* p, const double* kij)
{
int i;
double bm_factor[4], V[4];
for(i=0; i<4; i++)
{
V[i] = y[i*N_EQ1];
derivs_one(y+i*N_EQ1, dydt+i*N_EQ1, p);
bm_factor[i] = boltzmann(V[i], THRESHOLD, THRESHOLD_SLOPE)/C_m;
}
dydt[0] += (E_syn-V[0])*(kij[0]*bm_factor[1] + kij[1]* bm_factor[2] + kij[2]* bm_factor[3]);
dydt[N_EQ1] += (E_syn-V[1])*(kij[3]*bm_factor[0] + kij[4]* bm_factor[2] + kij[5]* bm_factor[3]);
dydt[2*N_EQ1] += (E_syn-V[2])*(kij[6]*bm_factor[0] + kij[7]* bm_factor[1] + kij[8]* bm_factor[3]);
dydt[3*N_EQ1] += (E_syn-V[3])*(kij[9]*bm_factor[0] + kij[10]*bm_factor[1] + kij[11]*bm_factor[2]);
dydt[0] += (kij[12]*(V[1]-V[0]) + kij[13]*(V[2]-V[0]) + kij[14]*(V[3]-V[0]))/C_m;
dydt[N_EQ1] += (kij[12]*(V[0]-V[1]) + kij[15]*(V[2]-V[1]) + kij[16]*(V[3]-V[1]))/C_m;
dydt[2*N_EQ1] += (kij[13]*(V[0]-V[2]) + kij[15]*(V[1]-V[2]) + kij[17]*(V[3]-V[2]))/C_m;
dydt[3*N_EQ1] += (kij[14]*(V[0]-V[3]) + kij[16]*(V[1]-V[3]) + kij[17]*(V[2]-V[3]))/C_m;
}
double boltzmann_overpi (const double T) {
return boltzmann(T)/M_PI;
}
