// ############################## START FUNC ############################################
// Input is basically the 2 distances and one angle for each combination of two features
// and the mass point of the molecule. The two groups must also be identified as type1
// and type2 (feature types). These 4 parameters is given by the two first in the input.
// matrix1 ,matrix2 and grupper define how to interprete angles, distances and features.
// This is done by intervals and groups, orginally taken from the file intervalspec.txt.

function place_bits(feature_sorts, all_matrix, matrix1 ,matrix2 , grupper, gearing)
{

      var number_of_features=feature_sorts.length;

// The first step is to place the values from all_matrix in recognizable variables
// Three variables, limit, ng and nf, is also better developed to an explicit form.

      var anglematrix=all_matrix[0];
      var dist1matrix=all_matrix[1];
      var dist2matrix=all_matrix[2];
      var aintervals=matrix1.length;
      var dintervals=matrix2.length;
      var limit=gearing[0];
      var ng=gearing[1];
      var sortstring="";
      var slutmatrix=new Array(0);
      var utmatrix=new Array(0);
      var tupp0=new Array(0);
      var tupp1=new Array(0);
      var tupp2=new Array(0);
      var tupp3=new Array(0);
      var tupp4=new Array(0);
      var au=new Array(0);
      var n=0;
      var m=0;
      var p=0;
      var temp="";
      var ranking=0;
      var vvv="";
      var nymark="";
      var utvector=new Array(0);
all_matrix=false;  //releasing memory IN CASE OF GLOBAL SCOPE

slutmatrix=def_matrix(number_of_features ,number_of_features, 4, "");

for(n=0;n<number_of_features;n++){
for(m=0;m<number_of_features;m++){

if(n==m) continue;

for(p=0;p<aintervals;p++){
  if(matrix1[p][0] < anglematrix[n][m] && anglematrix[n][m] < matrix1[p][1]){
  slutmatrix[n][m][0]=slutmatrix[n][m][0]+p+" ";
  }
}
for(p=0;p<dintervals;p++){
  if(matrix2[p][0] < dist1matrix[n][m] && dist1matrix[n][m] < matrix2[p][1]){
  slutmatrix[n][m][1]=slutmatrix[n][m][1]+p+" ";
  }
}
for(p=0;p<dintervals;p++){
  if(matrix2[p][0] < dist2matrix[n][m] && dist2matrix[n][m] < matrix2[p][1]){
  slutmatrix[n][m][2]=slutmatrix[n][m][2]+p+" ";
  }
}

slutmatrix[n][m][3]=grupper[feature_sorts[n]];
slutmatrix[n][m][4]=grupper[feature_sorts[m]];
}
}

utmatrix=def_matrix(number_of_features ,number_of_features, 0, "");

for(n=0;n<number_of_features;n++){
for(m=0;m<n;m++){

ranking=parseInt(10*anglematrix[n][m]*dist1matrix[n][m]*dist2matrix[n][m])/1000000;
ranking=ranking+"000000";
ranking=ranking.substring(0,8);

anglematrix[n][m]=dec_round(anglematrix[n][m],2);
dist1matrix[n][m]=dec_round(dist1matrix[n][m],2);
dist2matrix[n][m]=dec_round(dist2matrix[n][m],2);

temp=slutmatrix[n][m][0];
tupp0=temp.split(" ");
temp=slutmatrix[n][m][1];
tupp1=temp.split(" ");
temp=slutmatrix[n][m][2];
tupp2=temp.split(" ");
temp=slutmatrix[n][m][3];
tupp3=temp.split(" ");
temp=slutmatrix[n][m][4];
tupp4=temp.split(" ");

// This is the main procedure where the position of each bit is set, in every single case
// based upon one combination of angleinterval+distanceinterval1+distanceinterval2+group1+group2.
// So every combination sets one bit. Two features can set many bits, because the actual
// features can be interpreted as belonging several groups, the distances can belong to
// different intervals, as can the angle. The same distances, same angle, and identical features,
// for another molecule will repeat all the bits in its bitstrings. If the features differ from
// one molecule to another, for instance amide in one and esther in another, some group can still
// be identical so at least some bits corresponds for the combinations involved.

// The bits (positions) are also ranked so it will be possible to order them and chop the list.
// Then it will be the same number of set bits in every string (for each molecule) and it will
// be less likely that two molekyles lookes similar (many corresponding 1 - hits) just because
// they are big and involves a greater number of bits. The ranking is crucial, because several
// bits can be set by just one pair of features. It can be good if not all bits of high
// priority in a molecule is the result of one single combination of 2 features.

for(p0=0;p0<tupp0.length-1;p0++){
for(p1=0;p1<tupp1.length-1;p1++){
for(p2=0;p2<tupp2.length-1;p2++){
for(p3=0;p3<tupp3.length-1;p3++){
for(p4=0;p4<tupp4.length-1;p4++){
/*
vvv=parseInt(tupp4[p4])+parseInt(tupp3[p3])*ng+parseInt(tupp2[p2])*ng*ng;
vvv=vvv+parseInt(tupp1[p1])*ng*ng*dintervals+parseInt(tupp0[p0])*ng*ng*dintervals*dintervals;
*/
vvv=tupp4[p4]-(-tupp3[p3])*ng-(-tupp2[p2])*ng*ng-(-tupp1[p1])*ng*ng*dintervals+-(-tupp0[p0])*ng*ng*dintervals*dintervals;

vvv=vvv/1000000;
utmatrix[n][m]=utmatrix[n][m]+"#"+ranking+" ";
vvv=vvv+"000000";
vvv=vvv.substring(0,8);
utmatrix[n][m]=utmatrix[n][m]+vvv+"__*"+anglematrix[n][m]+"_*"+dist1matrix[n][m]+"_*"+dist2matrix[n][m]+"_*%"+feature_sorts[n]+"%_*%"+feature_sorts[m]+"%";
}
}
}
}
}

}
}

// It may seem less good to first transfer all features to numbers and later eventually
// back again, but this is the chosen procedure to keep all functions isolated and the 
// complete handeling structured.

sortstring=utmatrix.join("");
au=sortstring.split(",");
sortstring=au.join("");
au=sortstring.split("#");
au=au.sort();
for(n=0;n<au.length;n++) au[n]=au[n].substring(9,au[n].length);
au=au.sort();
sortstring="";
nymark="%@%";
for(n=0;n<au.length;n++){
if(nymark.substring(0,8)!=au[n].substring(0,8)){
sortstring=sortstring+"#"+au[n];
nymark=au[n];
}
else{
sortstring=sortstring+"_/_"+au[n].substring(10,au[n].length);
}
}

sortstring=sortstring.substring(2,sortstring.length);

// There is two "#" in the beginning of the string. One is from utmatrix[n][m]=utmatrix[n][m]+"#"+ranking+" ";
// The other is from sortstring=sortstring+"#"+au[n];  Both rows give one extra "#" each for all segments,
// before splittning.

au=sortstring.split("#");
if(au.length<limit) limit=au.length;
utvector=new Array(limit);

for(n=0;n<limit;n++) utvector[n]=au[n]=Math.round(au[n].substring(0,8)*1000000)+"__"+au[n].substring(10,au[n].length);
var outstring=utvector.join("\n");
document.form1.text1.value=outstring;

// So the output format is angle, distance1, distance2, feature1, feature 2

return;
}

// ############################### end func ############################################