// いいいいいいいいいいいいいい Defining the List-object いいいいいいいいいいいいいい
// In this object function several strings can be created. The virtual strings list atom-ID
// for all atoms which fits in their respective category. string.Display() shows the "string"
// Variables in this function are:
  // Integers:                  n, qm, mem, sz, as
  // Integer number matrix:     connections, atom_sorts
  // Logical matrix             this.l
  // Mixed variable             def

     function List(def, connections, atom_sorts, rings)
     {
     this.l = new Array(atom_sorts.length);
     this.Display=Display;
     this.Add=Add;
     this.Check=Check;
     this.Span=Span;
     this.First=First;
var n=0;
var sz=0;
var as=0;
if(def!="empty"){
for(n=0;n<atom_sorts.length;n++){
  sz=parseInt(connections[n].length);
  as=parseInt(atom_sorts[n]);
  // The following technique in a loop is a bit lavish, but the main task is not fast
  // performance, but a viewable scheme.
    switch(def){
      case 4:
        // Remember that the connections are sorted wih respect to atom sort
        if(sz>3 && atom_sorts[connections[n][3]]>1) this.Add(n);
        break;
      case 3:
        // Remember that the connections are sorted wih respect to atom sort
        if(sz==3 && atom_sorts[connections[n][2]]>1) this.Add(n);
        if(sz==4 && atom_sorts[connections[n][2]]>1 && atom_sorts[connections[n][3]]==1) this.Add(n);
        break;
      case "branch":
        // ie case 4 OR case 3
        if(sz>2 && atom_sorts[connections[n][2]]>1) this.Add(n);
        break;
      case "carbon4":
        // like the central all carbon binding carbon in morphine (can be chiral)
        var mem=0;
        var q=0;
          if(sz==4 && as==6){            // well
          for(q=0;q<sz;q++){
           if(atom_sorts[connections[n][q]]==6) mem++;
          }
          }
        if(mem==4) this.Add(n);
        break;
      case 2:
        // This routine lists only possible ring atoms, not all "2-branches"
        var mem=0;
        var q=0;
          for(q=0;q<sz;q++){
           if(connections[connections[n][q]].length>1) mem++;
          }
        if(mem>1) this.Add(n);
        break;
      case "branch3":
        // Like case = 2, but for branches which does not end instantly -> mem>2
        // This is necessary to make the judgements when a conjugated area is scrutinized.
        var mem=0;
        var q=0;
        var asa=0;
        var bsa=0;
          for(q=0;q<sz;q++){
          asa=atom_sorts[connections[n][q]];
          bsa=connections[connections[n][q]].length;
          if(asa==6 && bsa==3)  mem++;
         if(asa==7 && bsa==2)   mem++;
          if(asa==8 && bsa==1)  mem++;
         if(asa==16 && bsa==1)  mem++;
          }
        if(mem>2) this.Add(n);
        break;
      case "fat":
        // Carbons that can build a fatty complex. They do not link to other molecules then H & C, 
        // for simplicity. Ring atoms are excluded
         if(as==6 && rings.indexOf(" "+n+" ")==-1){
         var mem=0;
         var q=0;
           for(q=0;q<sz;q++){
            if(atom_sorts[connections[n][q]]!=6 && atom_sorts[connections[n][q]]!=1) mem++;
           }
         if(mem==0) this.Add(n);
         }
        break;
      case "ends":
         if(as==6){
         // Carbons that can act as ends in a fatty complex. 
         var mem=0;
         var q=0;
           for(q=0;q<sz;q++){
            if(atom_sorts[connections[n][q]]!=1) mem++;
           }
         if(mem<2) this.Add(n);
         }
        break;
      case "chir":
        // if the third [2] connection is a hydrogen, the fourth [3] must be the same
        if(sz==4 && atom_sorts[connections[n][2]]!=1) this.Add(n);
        break;
      case "double":
          if(as==6 && sz==3) this.Add(n);
         if(as==7 && sz==2) this.Add(n);
          if(as==8 && sz==1) this.Add(n);
         if(as==16 && sz==1) this.Add(n);
        break;
      case "triple":
          if(as==7 && sz==1) this.Add(n);
         if(as==6 && sz==2) this.Add(n);
        break;
      case "cunjugate_end":
         // This routine search for ends of conjugated complex.
         // This means that the atom n must have just one multiple bonded neighbour
         var mem=1;  // One of the connections must of course be of double nature ... mem=1
         var q=0;
         if((sz+as<10 && as!=1) || sz+as==17){
             for(q=0;q<sz;q++){
              if(connections[connections[n][q]].length==1){
               // The row below is required to not let O= or S= look like a single bonded neighbour
               if(atom_sorts[connections[n][q]]==8 || atom_sorts[connections[n][q]]==16) continue;
              mem++;
              continue;         // To not count some halogens twice
              }
             if(parseInt(connections[connections[n][q]].length)+parseInt(atom_sorts[connections[n][q]])==10) mem++;
             if(parseInt(connections[connections[n][q]].length)+parseInt(atom_sorts[connections[n][q]])==18) mem++;
             }
          if(mem==q) this.Add(n);
         }
        break;
      case "carbonyle":
        // In this case n is NOT added. The connected carbon is added.
         if((as==8 || as==16) && sz==1) this.Add(connections[n][0]);
        break;

    }
}  //   end of long loop
}  //   end of long if
     }

// ------------------------Span--------------------------
       function Span()
       {
         var mem=0;
         for(n=0;n<this.l.length;n++){
          if(this.l[n]) mem++;
         }
       return mem;
       }
// ------------------------First--------------------------
       function First()
       {
         var mem=-1;
         for(n=0;n<this.l.length;n++){
          if(this.l[n]){
          mem=n;
          break;
          }
         }
       return mem;
       }

// ------------------------Display------------------------
       // Method display returns a string with all atoms in that object (virtual list)
       // Hence, carbonyles.Display() lists all carbonyles, although the atoms in
       // that list are indexed variables: this.l[atom-ID] those are logical
       // This is mainly a HELP-FUNCTION when rewriting or checking the program
       function Display()
       {
       var q= "";
         for(n=0;n<this.l.length;n++){
          if(this.l[n]==true) q=q+n+" ";
         }
       if(q.length>0) q=q.substring(0,q.length-1);
       return (q);
       }
// ------------------------Add----------------------------
     // Adds a atom to the virtual list
     function Add(jr)
     {
     this.l[jr]=true;
     }
// ------------------------Check--------------------------
       // Returns true if the atom is on the virtual list, else false
       function Check(jr)
       {
       if(this.l[jr]){
       return true;
       }
       else{
       return false;
       // Which covers also "undefined"
       }
}
// いいいいいいいいいいいいいい End definition List-object いいいいいいいいいいいいいい