monster function

antisort_index.js

  function aindex(mx,Ai,sq,sep,lim,x){  //Sorry but its working....
    var Av,i
    if( typeof mx !=='boolean')
    { x=lim,lim=sep,sep=sq,sq=Ai,Ai=mx,mx=true }
    if( typeof Ai !=='object' || (isNaN(parseFloat(Ai[0])) || !isFinite(Ai[0]))
     ||(typeof sep ==='string' && sep==="pos")){ 
      Av= new Array((Ai>0)?Ai:Ai.length)
      if( typeof sq ==='undefined') sq=1
      if(sep ==="pos"){ sep=lim,lim=x }
      for( i=0;i<Av.length;i++ ) Av[i]=i
    }else{ Av=Ai,sq=sq||0 }
    
    var ne=Av.length, nc=ne>50?50:ne-1, nd=ne>350?350:ne-1

    var Ax= new Array(ne); for(var i=0;i<ne;i++) Ax[i]=i
        
    if(ne<1) return Ax   //handle diminutive arrays
    if(mx) mixup(Ax)
    if(ne==2){ 
      if ((sq<0)^(Av[Ax[1]]>Av[Ax[0]]))
      { return [Ax[1],Ax[0]] }else{ return Ax } 
    }
         
    var autosep=false, bsep=(sep===0)?"zero":sep, csep=sep*0.5
    if( typeof sep ==='undefined' || sep==="auto" ){ 
      var kd=0, np=(ne*0.33)|0, nq=1+(ne*0.66)|0 
      for( i=0;i<nd;i++){
        kd+=Math.abs(Av[i]-Av[(np+i)%ne])
          + Math.abs(Av[(np+i)%ne]-Av[(nq+i)%ne])
          + Math.abs(Av[(ne+nq-i)%ne]-Av[(ne-i)%ne]) 
      } 
      autosep=true, sep=bsep=kd/(nd*10), csep=sep*0.5
    }
    if(ne<10) autosep=false
    if(!lim){ lim=(ne+500000)*0.001 }
    var ti=lim*8000, te=ti*0.3 
    
    var t=0, j=0, jr=0, jm=0, c=irange(1,ne-1), ch=ne+3, jm=0, lw=false
    
    while( ch>0 && ti>0 ) { 
      
      var ib=(c=c<0?c+ne:c)%ne, ic=ib+1, id=ib+2, ie=ib+3
      if(ie>=ne){ ie=ie-ne,id=id%ne,ic=ic%ne }
      
      var stick=0 ,d=1 
      
      if(autosep){ sep=bsep*range(0.83333,1.2),csep=sep*0.5 }

      if(Math.abs(Av[Ax[ic]]-Av[Ax[id]]+sq)<sep){  //1-away collision 
        jm=irange(2,nd)+ic, jr=jm+nc, stick=1, d=-2, lw=ti<te
        while ( stick && jm<jr ){ 
          j=jm%ne 
          if( Math.abs(Av[Ax[id]]-Av[Ax[j]]+sq)>=sep 
           && Math.abs(Av[Ax[(j+1)%ne]]-Av[Ax[ic]]+sq)>=sep
           && (lw || Math.abs(Av[Ax[ie]]-Av[Ax[j]]+sq)>=csep) 
          ){ 
            stick=0, t=Ax[ic], Ax[ic]=Ax[j], Ax[j]=t 
            if(jm-ic+2>ch){ ch=jm-ic+2 }
          }
          jm++;
        } 
        var f=(jm-jr+nc)*0.5; ti-=f
        if(stick){ t=Ax[ib], Ax[ib]=Ax[ic], Ax[ic]=t }
        if(autosep) { bsep*= (66-((f-2)/nc))*0.0151466 } 
        
      }else{ //1-away good, check 2-away
        if( ti>te && Math.abs(Av[Ax[ic]]-Av[Ax[ie]]+sq)<csep ) 
        { stick=1, jm=irange(2,nd)+ic, jr=jm+nc 
          while ( stick && jm<jr ){ 
            j=jm%ne
            if(Math.abs(Av[Ax[id]]-Av[Ax[j]]+sq)>=sep
             &&Math.abs(Av[Ax[(j+1)%ne]]-Av[Ax[ie]]+sq)>=sep
             &&Math.abs(Av[Ax[ic]]-Av[Ax[j]]+sq)>=csep)
            { 
              stick=0,t=Ax[ie], Ax[ie]=Ax[j], Ax[j]=t
              if(jm-ic+2>ch){ ch=jm-ic+2 }
            }
            jm++
          }
          ti-=(jm-jr+nc)*0.5
        }
      }
      c=c+d, ch=ch-d, ti-- 
    }
    
    if(autosep){ us=(ti>te)?bsep*0.81:(ti<1)?0:-bsep*0.8 }
    else{ us=(ti>te)?bsep:(ti<1)?0:-bsep }
    
    return Ax
}