//structured monte carlo
//maintains correct blockstructure doesnt work very good
void oku_mcblksol(oku_sod* sod, double temp){
int i,j,k,val;
int fit1, fit2, num,blk,idx1,idx2,tmp;
int size = sod->size;
int blkunk[size],cnt[size];
int blkunkidx[size][size];
for(i=0;i<size;i++){
blkunk[i] = 0;
for(j=0;j<size;j++)
cnt[j] = 0;
//find unknowns for every block
for(j=0;j<size;j++){
val = get_blk(sod,i,j);
if(val == 0){
blkunkidx[i][blkunk[i]++] = j;
} else {
if(cnt[val-1] == 0){
cnt[val-1] = 1;
} else printf("Fehler in oku_mcblocksol: Invalid hint: %d\n",val);
}
}
//fill them
k=0;
for(j=0;j<size;j++)
if(cnt[j] == 0)
set_blk(sod,i,blkunkidx[i][k++],j+1);
}
oku_sod_print(sod);
fit1 = fitness(sod);
num = 0;
while(fit1){
//choose block and two indizes inside
blk = rndi() % size;
idx1 = rndi() % blkunk[blk];
idx2 = rndi() % blkunk[blk];
//swap
tmp = get_blk(sod,blk,idx1);
set_blk(sod,blk,idx1,get_blk(sod,blk,idx2));
set_blk(sod,blk,idx2,tmp);
fit2 = fitness(sod);
if(fit2 > fit1 && exp((fit1 - fit2)/temp) < rndf()){
//swap back
tmp = get_blk(sod,blk,idx1);
set_blk(sod,blk,idx1,get_blk(sod,blk,idx2));
set_blk(sod,blk,idx2,tmp);
} else fit1 = fit2;
num++;
if(num % 2000 == 0)
printf("Step:%d Fitness: %d\n",num,fit1);
}
}
int hop_pattern(NSLNSLnet *net,va_list args)
{ int nn;
hop_io_ds *hp=nsl_drv(hop_io_ds); nio_ds *np=(&hp->nio);
np->xx=0;
dsi(np->d0,hop_ctrl_ds,stable)=2;
for(nn=0;nn<np->fld_siz;++nn) dsf(np->d0,hop_ctrl_ds,output[nn])=rndf();
return(0);
}
void tick()
{
d.minus(e, p);
if (d.quadLen() < 0.0001)
{
e.init(-0.966918f - 0.75f + 0.9f * rndf(),
2.879879f - 0.0f + 1.0f * rndf(),
0.765145f - 1.7f + 1.6f * rndf(),
0.744728f - 0.5f + 0.6f * rndf());
__android_log_print(ANDROID_LOG_VERBOSE, "StrangeAttractor", "new position");
}
v.plus(d, 0.01);
p.plus(v, 0.01);
v.scale(0.99);
}
// first monte carlo solver, mildly constraint
void oku_mcsol(oku_sod* sod, double temp){
int i,j,num,size = sod->size;
int cnt[size+1];
int fit1, fit2, idx1, idx2,tmp,tmp2;
//refresh list of unknowns in sod
unk_find(sod);
//fill sudoku with missing symbols
for(i=1;i<size+1;i++) cnt[i] = size;
for(i=0;i<size*size;i++)
cnt[get_idx(sod,i)]--;
j=1;
for(i=0;i<get_numunk(sod);i++){
while(cnt[j] < 1 && j <= size+1) j++;
cnt[j]--;
set_idx(sod,get_unkidx(sod,i),j);
}
fit1 = fitness(sod);
num=0;
while(fit1 && num < 200000){
//choose 2 indices
idx1 = get_unkidx(sod,rndi() % get_numunk(sod));
idx2 = get_unkidx(sod,rndi() % get_numunk(sod));
//swap
tmp = get_idx(sod,idx1);
if(tmp == (tmp2 = get_idx(sod,idx2))) continue;
set_idx(sod,idx1,tmp2);
set_idx(sod,idx2,tmp);
fit2 = fitness(sod);
if(fit2 > fit1 && exp((fit1 - fit2)/temp) < rndf()){
//swap back
tmp = get_idx(sod,idx1);
set_idx(sod,idx1,get_idx(sod,idx2));
set_idx(sod,idx2,tmp);
} else fit1 = fit2;
num++;
}
printf("Solution found after %d MC Steps\n",num);
};
// completely unconstrained monte carlo
void oku_mcsol2(oku_sod* sod, double temp){
int i,j,num,size = sod->size;
int cnt[size+1];
int fit1, fit2, idx1, idx2,tmp;
//refresh list of unknowns in sod
unk_find(sod);
//fill sudoku with missing symbols
for(i=0;i<get_numunk(sod);i++){
set_idx(sod,get_unkidx(sod,i),(rndi() % sod->size) + 1);
}
fit1 = fitness(sod);
num=0;
while(fit1 && num < 200000){
//choose 2 indices
idx1 = get_unkidx(sod,rndi() % get_numunk(sod));
tmp = get_idx(sod,idx1);
set_idx(sod,idx1,(rndi() % sod->size) + 1);
fit2 = fitness(sod);
if(fit2 > fit1 && exp((fit1 - fit2)/temp) < rndf()){
//swap back
set_idx(sod,idx1,tmp);
} else fit1 = fit2;
num++;
}
printf("Solution found after %d MC Steps\n",num);
};
float _rnd( void)
{
return( .34 + ( rndf() * .8 * ( rnd_range(0,2) % 2)));
}
float rndr(void)
{
return ( ( rndf() - 0.5) * 2.0f );
}
int ocos_probe(NSLNSLnet *net,va_list args)
{ nio_ds *np=nsl_drv(nio_ds); np->xx=0;
dsf(np->d0,data_ds,output)=rndf(); dsf(np->d0+1,data_ds,output)=rndf();
return(0);
}
